aGrUM's Tensor is a multi-dimensional array with tensor operators. More...

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

Inheritance diagram for gum::Tensor< GUM_SCALAR >:

Collaboration diagram for gum::Tensor< GUM_SCALAR >:

Public Member Functions
Constructors, Destructors and Copy
	Tensor ()
	Default constructor.
	Tensor (const std::vector< const DiscreteVariable * > &vars)
	Default constructor.
	Tensor (MultiDimImplementation< GUM_SCALAR > *aContent)
	Creates an tensor around aContent.
	Tensor (MultiDimImplementation< GUM_SCALAR > *aContent, const MultiDimContainer< GUM_SCALAR > &src)
	Copy constructor.
	Tensor (const Tensor< GUM_SCALAR > &src)
	Copy constructor & assignment.
Tensor< GUM_SCALAR > &	operator= (const Tensor< GUM_SCALAR > &src)
	Default constructor.
	Tensor (Tensor< GUM_SCALAR > &&from)
	move constructor & assignement
Tensor< GUM_SCALAR > &	operator= (Tensor< GUM_SCALAR > &&src)
	Default constructor.
	~Tensor () final
	Destructor.
MultiDimContainer implementation
Tensor< GUM_SCALAR > *	newFactory () const final
	Default implementation of MultiDimContainer::set().
Class operation for Tensor instances
const Tensor< GUM_SCALAR > &	random () const
	generate a random Tensor with each parameter in [0,1]
const Tensor< GUM_SCALAR > &	randomDistribution () const
	generate a random Distribution in the Tensor
const Tensor< GUM_SCALAR > &	randomCPT () const
	generate a random CPT in the Tensor
const Tensor< GUM_SCALAR > &	noising (GUM_SCALAR alpha) const
	add a noise in a CPT by mixing (1-alpha)this+alpha.randomCPT()
Tensor< GUM_SCALAR >	sumOut (const gum::VariableSet &del_vars) const
	Projection using sum as operation (and implementation-optimized operations).
Tensor< GUM_SCALAR >	sumIn (const gum::VariableSet &kept_vars) const
	Projection using sum as operation (and implementation-optimized operations).
Tensor< GUM_SCALAR >	prodOut (const gum::VariableSet &del_vars) const
	Projection using multiplication as operation (and implementation-optimized operations).
Tensor< GUM_SCALAR >	prodIn (const gum::VariableSet &kept_vars) const
	Projection using multiplication as operation (and implementation-optimized operations).
Tensor< GUM_SCALAR >	minOut (const gum::VariableSet &del_vars) const
	Projection using min as operation (and implementation-optimized operations).
Tensor< GUM_SCALAR >	minIn (const gum::VariableSet &kept_vars) const
	Projection using min as operation (and implementation-optimized operations).
Tensor< GUM_SCALAR >	maxOut (const gum::VariableSet &del_vars) const
	Projection using max as operation (and implementation-optimized operations).
Tensor< GUM_SCALAR >	maxIn (const gum::VariableSet &kept_vars) const
	Projection using max as operation (and implementation-optimized operations).
Tensor< GUM_SCALAR >	isNonZeroMap () const
	create a boolean-like tensor using the predicate isNonZero
GUM_SCALAR	sum () const
	sum of all elements in the Tensor
GUM_SCALAR	product () const
	product of all elements in the Tensor
GUM_SCALAR	max () const
	max of all elements in the Tensor
GUM_SCALAR	min () const
	min of all elements in the Tensor
GUM_SCALAR	maxNonOne () const
	max of all non one elements in the Tensor
GUM_SCALAR	minNonZero () const
	min of all non zero elements in the Tensor
Set< Instantiation >	findAll (GUM_SCALAR v) const
	set of instantiation corresponding to the parameter v in the Tensor
std::pair< Set< Instantiation >, GUM_SCALAR >	argmax () const
	Pair of the set of instantiation corresponding to the max and this max in the Tensor.
std::pair< Set< Instantiation >, GUM_SCALAR >	argmin () const
	Pair of the set of instantiation corresponding to the min and this min in the Tensor.
GUM_SCALAR	expectedValue (std::function< GUM_SCALAR(const gum::Instantiation &) >) const
	ExpectedValue computes the expectation of f over *this.
GUM_SCALAR	entropy () const
	entropy of the Tensor
Tensor< GUM_SCALAR >	reorganize (const std::vector< const DiscreteVariable * > &vars) const
	create a new Tensor with another order
Tensor< GUM_SCALAR >	reorganize (const std::vector< std::string > &vars) const
	create a new Tensor with another order
Tensor< GUM_SCALAR >	extract (const Instantiation &inst) const
	create a new Tensor extracted from *this given a partial instantiation
Tensor< GUM_SCALAR >	putFirst (const DiscreteVariable *var) const
	create a new Tensor with a certain variable in first
Tensor< GUM_SCALAR >	putFirst (const std::string &varname) const
	create a new Tensor with a certain variable in first
const Tensor< GUM_SCALAR > &	fillWith (const Tensor< GUM_SCALAR > &src) const
	copy a Tensor data using name of variables and labels (not necessarily the same variables in the same orders)
const Tensor< GUM_SCALAR > &	fillWith (const Tensor< GUM_SCALAR > &src, const std::vector< std::string > &mapSrc) const
	copy a Tensor data using the sequence of names in mapSrc to find the corresponding variables.
const Tensor< GUM_SCALAR > &	fillWith (const std::vector< GUM_SCALAR > &data) const
	Automatically fills the tensor with the values in v.
const Tensor< GUM_SCALAR > &	fillWith (const GUM_SCALAR &val) const
	Automatically fills this MultiDimContainer with the value v.
const Tensor< GUM_SCALAR > &	abs () const
	Apply abs on every element of the container.
const Tensor< GUM_SCALAR > &	sq () const
	apply $x^2$ on every element of the container
const Tensor< GUM_SCALAR > &	log2 () const
	apply $log_2(x)$ on every element of the container
const Tensor< GUM_SCALAR > &	sgn () const
	apply sgn(x)$ on every element of the container
Tensor< GUM_SCALAR >	new_abs () const
	Create a new tensor and apply abs on every element of the container.
Tensor< GUM_SCALAR >	new_sq () const
	Create a new tensor and apply $x^2$ on every element of the container.
Tensor< GUM_SCALAR >	new_log2 () const
	Create a new tensor and apply $log_2(x)$ on every element of the container.
Tensor< GUM_SCALAR >	new_sgn () const
	Create a new tensor and apply sgn(x)$ on every element of the container.
const Tensor< GUM_SCALAR > &	normalize () const
	normalisation of this do nothing if sum is 0
GUM_SCALAR	KL (const Tensor< GUM_SCALAR > &p) const
	compute KL divergence between this and p Checks the compatibility and then compute KL divergence
const Tensor< GUM_SCALAR > &	normalizeAsCPT (const Idx &varId=0) const
	normalisation of this as a CPT for the variable varId
const Tensor< GUM_SCALAR > &	scale (GUM_SCALAR v) const
	multiply (each value of) *this by v
const Tensor< GUM_SCALAR > &	translate (GUM_SCALAR v) const
	add v to (each value of) *this
const Tensor< GUM_SCALAR > &	inverse () const
	the function to inverse (each value of) *this
Idx	draw () const
	get a value at random from a 1-D distribution
Size	memoryFootprint () const
	compute the (approximated) footprint in memory of the tensor
Tensor algebra operators
Tensor< GUM_SCALAR >	operator+ (const Tensor< GUM_SCALAR > &p2) const
	the function to be used to add two Tensors
Tensor< GUM_SCALAR >	operator+ (const GUM_SCALAR &v) const
	the function to be used to add a GUM_SCALAR to a Tensor
Tensor< GUM_SCALAR >	operator- (const Tensor< GUM_SCALAR > &p2) const
	the function to be used to subtract two Tensors
Tensor< GUM_SCALAR >	operator- (const GUM_SCALAR &v) const
	the function to be used to substract a GUM_SCALAR from a Tensor
Tensor< GUM_SCALAR >	operator* (const Tensor< GUM_SCALAR > &p2) const
	the function to be used to multiply two Tensors
Tensor< GUM_SCALAR >	operator* (const GUM_SCALAR &v) const
	the function to be used to multiply a Tensor and a scalar
Tensor< GUM_SCALAR >	operator/ (const Tensor< GUM_SCALAR > &p2) const
	the function to be used to divide two Tensors
Tensor< GUM_SCALAR >	operator/ (const GUM_SCALAR &v) const
	the function to be used to divide a Tensor by a scalar
Tensor< GUM_SCALAR > &	operator+= (const Tensor< GUM_SCALAR > &r)
	the function to be used to add two Tensors
Tensor< GUM_SCALAR > &	operator+= (const GUM_SCALAR &v)
	the function to be used to add two Tensors
Tensor< GUM_SCALAR > &	operator*= (const Tensor< GUM_SCALAR > &r)
	the function to be used to add two Tensors
Tensor< GUM_SCALAR > &	operator*= (const GUM_SCALAR &v)
	the function to be used to add two Tensors
Tensor< GUM_SCALAR > &	operator-= (const Tensor< GUM_SCALAR > &r)
	the function to be used to add two Tensors
Tensor< GUM_SCALAR > &	operator-= (const GUM_SCALAR &v)
	the function to be used to add two Tensors
Tensor< GUM_SCALAR > &	operator/= (const Tensor< GUM_SCALAR > &r)
	the function to be used to add two Tensors
Tensor< GUM_SCALAR > &	operator/= (const GUM_SCALAR &v)
	the function to be used to add two Tensors
bool	isEvidence () const
	is an evidence ? (marginal-like but has not to sum to 1)
Tensor< GUM_SCALAR >	operator\| (const Tensor< GUM_SCALAR > &p2) const
	the function to be used to add two Tensors
Tensor< GUM_SCALAR >	operator& (const Tensor< GUM_SCALAR > &p2) const
	the function to be used to add two Tensors
Tensor< GUM_SCALAR >	operator~ () const
	the function to be used to add two Tensors
bool	operator== (const Tensor< GUM_SCALAR > &r) const
	the function to be used to add two Tensors
Tensor< GUM_SCALAR > &	operator<< (const DiscreteVariable &v)
	the function to be used to add two Tensors
std::string	toString () const final
	the function to be used to add two Tensors
MultiDimInterface implementation
virtual Idx	nbrDim () const final
	Returns the number of vars in the multidimensional container.
virtual Size	domainSize () const final
	Returns the product of the variables domain size.
virtual void	add (const DiscreteVariable &v) final
	Adds a new var to the variables of the multidimensional matrix.
virtual void	erase (const DiscreteVariable &var) final
	Removes a var from the variables of the multidimensional matrix.
virtual void	erase (const std::string &name) final
virtual const Sequence< const DiscreteVariable * > &	variablesSequence () const final
	Returns a const ref to the sequence of DiscreteVariable*.
virtual const DiscreteVariable &	variable (Idx) const final
	Returns a const ref to the ith var.
virtual const DiscreteVariable &	variable (const std::string &name) const final
	Returns the variable with the name.
virtual Idx	pos (const DiscreteVariable &var) const final
	Returns the index of a variable.
virtual bool	contains (const DiscreteVariable &var) const final
	Returns true if var is in *this.
virtual bool	empty () const final
	Returns true if no var is in *this.
MultiDimAddressable implementation
virtual bool	unregisterSlave (Instantiation &i) final
	Unregister i as a slave of this MultiDimAdressable.
virtual bool	registerSlave (Instantiation &i) final
	Register i as a slave of this MultiDimAdressable.
virtual void	changeNotification (const Instantiation &i, const DiscreteVariable *const var, Idx oldval, Idx newval) final
	Listen to changes in a given Instantiation.
virtual void	setChangeNotification (const Instantiation &i) final
	Listen to an assignment of a value in a Instantiation.
virtual void	setFirstNotification (const Instantiation &i) final
	Listen to setFirst in a given Instantiation.
virtual void	setLastNotification (const Instantiation &i) final
	Listen to setLast in a given Instantiation.
virtual void	setIncNotification (const Instantiation &i) final
	Listen to increment in a given Instantiation.
virtual void	setDecNotification (const Instantiation &i) final
	Listen to increment in each recorded Instantiation.
virtual void	notifyChange () const final
MultiDimContainer implementation
virtual void	set (const Instantiation &i, const GUM_SCALAR &value) const final
	Default implementation of MultiDimContainer::set().
virtual GUM_SCALAR	get (const Instantiation &i) const final
	Default implementation of MultiDimContainer::get().
virtual void	fill (const GUM_SCALAR &d) const final
	Default implementation of MultiDimContainer::set().
virtual void	populate (const std::vector< GUM_SCALAR > &v) const final
	Automatically fills this MultiDimContainer with the values in v.
virtual void	apply (std::function< GUM_SCALAR(GUM_SCALAR) > f) const final
	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 final
	compute lfold for this container
virtual void	beginMultipleChanges () final
	Default implementation of MultiDimContainer::set().
virtual void	endMultipleChanges () final
	Default implementation of MultiDimContainer::set().
virtual void	endMultipleChanges (const GUM_SCALAR &) final
	Default implementation of MultiDimContainer::set().
virtual std::string	toString (const Instantiation *i) const
	Default implementation of MultiDimContainer::set().
Accessors / Modifiers
virtual void	populate (std::initializer_list< GUM_SCALAR > l) const
	Automatically fills this MultiDimContainer with the values in l.
GUM_SCALAR	operator[] (const Instantiation &i) const
	An [] operator using a Instantiation as argument.
Various methods.
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).
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.
Various methods.
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.
Accessors / Modifiers
void	replace (const DiscreteVariable &x, const DiscreteVariable &y)
	Replace variables in this multidim.

Static Public Member Functions
static Tensor< GUM_SCALAR >	deterministicTensor (const DiscreteVariable &var, Idx value)
static Tensor< GUM_SCALAR >	deterministicTensor (const DiscreteVariable &var, const std::string &label)
static Tensor< GUM_SCALAR >	uniformTensor (const DiscreteVariable &var)

static Tensor< GUM_SCALAR >	evEq (const DiscreteVariable &v, double val)
	numerical evidence generator
static Tensor< GUM_SCALAR >	evIn (const DiscreteVariable &v, double val1, double val2)
	numerical evidence generator
static Tensor< GUM_SCALAR >	evGt (const DiscreteVariable &v, double val)
	numerical evidence generator
static Tensor< GUM_SCALAR >	evLt (const DiscreteVariable &v, double val)
	numerical evidence generator

Protected Member Functions
gum::VariableSet	complementVars_ (const gum::VariableSet &del_vars) const
virtual void	replace_ (const DiscreteVariable x, const DiscreteVariable y)
	This is called by MultiDimContainer::replace() to proceed with the replacing between x and y.
void	swapContent_ (MultiDimImplementation< GUM_SCALAR > *aContent) const
	protected method to swap the implementation behind the Tensor
GUM_SCALAR &	get_ (const Instantiation &i) const final
	Return a data, given a Instantiation - final method.

Protected Attributes
MultiDimImplementation< GUM_SCALAR > *	content_
	The true container.
GUM_SCALAR	empty_value_
	value of the MultiDimDecorator if no dimension.

Detailed Description

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

aGrUM's Tensor is a multi-dimensional array with tensor operators.

It is used to represent probabilities and utilities in aGrUMs' multidimensional (graphical) models.

Using the decorator pattern, this representation is independent from the implementation of the multidimensional matrix.

Template Parameters

GUM_SCALAR The type of the scalar stored in this multidimensional matrix.

Warning: The Tensor class is not thread-safe. If you want to use it in a threaded context, you have to use a mutex to protect the access to the class.; The Tensor class does not contain its variables. It only contains (maybe dangling) pointers to the variables.

Definition at line 85 of file tensor.h.

Constructor & Destructor Documentation

◆ Tensor() [1/6]

template<typename GUM_SCALAR>

INLINE gum::Tensor< GUM_SCALAR >::Tensor ( )

Default constructor.

Creates an empty null dimensional matrix with a MultiDimArray as its implementation.

Definition at line 61 of file tensor_tpl.h.

                                      :
      MultiDimDecorator< GUM_SCALAR >(new MultiDimArray< GUM_SCALAR >(), GUM_SCALAR(1)) {
    GUM_CONSTRUCTOR(Tensor)
  }

References gum::MultiDimDecorator< GUM_SCALAR >::MultiDimDecorator(), and Tensor().

Referenced by Tensor(), Tensor(), Tensor(), Tensor(), Tensor(), Tensor(), ~Tensor(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Tensor() [2/6]

template<typename GUM_SCALAR>

INLINE gum::Tensor< GUM_SCALAR >::Tensor ( const std::vector< const DiscreteVariable * > & vars )

Default constructor.

Creates an empty null dimensional matrix with a MultiDimArray as its implementation and add the vars

Definition at line 69 of file tensor_tpl.h.

                                                                                      :
      Tensor() {
    for (const auto& var: vars) {
      this->add(*var);
    }
  }

References Tensor(), and gum::MultiDimDecorator< GUM_SCALAR >::add().

Here is the call graph for this function:

◆ Tensor() [3/6]

template<typename GUM_SCALAR>

INLINE gum::Tensor< GUM_SCALAR >::Tensor ( MultiDimImplementation< GUM_SCALAR > * aContent )

explicit

Creates an tensor around aContent.

Parameters

aContent The implementation of this Tensor.

Definition at line 78 of file tensor_tpl.h.

                                                                                    :
      MultiDimDecorator< GUM_SCALAR >(aContent, GUM_SCALAR(1)) {
    // for debugging purposes
    GUM_CONSTRUCTOR(Tensor)
  }

References gum::MultiDimDecorator< GUM_SCALAR >::MultiDimDecorator(), and Tensor().

Here is the call graph for this function:

◆ Tensor() [4/6]

template<typename GUM_SCALAR>

gum::Tensor< GUM_SCALAR >::Tensor	(	MultiDimImplementation< GUM_SCALAR > *	aContent,
		const MultiDimContainer< GUM_SCALAR > &	src )

Copy constructor.

The newly created Tensor share the variables and the values from src, but no instantiation is associated to it. It allows to force the chosen implementation and to copy the data from src.

Parameters

aContent	The implementation to use in this Tensor.
src	The MultiDimContainer to copy.

Definition at line 104 of file tensor_tpl.h.

                                                                           :
      MultiDimDecorator< GUM_SCALAR >(aContent) {
    // for debugging purposes
    GUM_CONSTRUCTOR(Tensor)
 
    if (!src.empty()) {
      this->beginMultipleChanges();
 
      for (Idx i = 0; i < src.variablesSequence().size(); i++) {
        this->add(*(src.variablesSequence()[i]));
      }
 
      this->endMultipleChanges();
      this->content()->copyFrom(*src.content());
    }
  }

References gum::MultiDimDecorator< GUM_SCALAR >::MultiDimDecorator(), Tensor(), gum::MultiDimDecorator< GUM_SCALAR >::add(), gum::MultiDimDecorator< GUM_SCALAR >::beginMultipleChanges(), gum::MultiDimContainer< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimInterface::empty(), gum::MultiDimDecorator< GUM_SCALAR >::endMultipleChanges(), and gum::MultiDimInterface::variablesSequence().

Here is the call graph for this function:

◆ Tensor() [5/6]

template<typename GUM_SCALAR>

INLINE gum::Tensor< GUM_SCALAR >::Tensor ( const Tensor< GUM_SCALAR > & src )

Copy constructor & assignment.

Definition at line 86 of file tensor_tpl.h.

                                                                     :
      Tensor< GUM_SCALAR >(
          static_cast< MultiDimImplementation< GUM_SCALAR >* >(src.content()->newFactory()),
          *(src.content())) {
    this->empty_value_ = src.empty_value_;
    // GUM_CONS_CPY not here because in called Tensor
    // GUM_CONS_CPY( Tensor );
  }

References Tensor(), gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, and newFactory().

Here is the call graph for this function:

◆ Tensor() [6/6]

template<typename GUM_SCALAR>

INLINE gum::Tensor< GUM_SCALAR >::Tensor ( Tensor< GUM_SCALAR > && from )

move constructor & assignement

move constructor

Definition at line 97 of file tensor_tpl.h.

                                                                 :
      MultiDimDecorator< GUM_SCALAR >(std::forward< MultiDimDecorator< GUM_SCALAR > >(from)) {
    GUM_CONS_MOV(Tensor)
  }

References gum::MultiDimDecorator< GUM_SCALAR >::MultiDimDecorator(), and Tensor().

Here is the call graph for this function:

◆ ~Tensor()

template<typename GUM_SCALAR>

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

final

Destructor.

Definition at line 144 of file tensor_tpl.h.

                                {
    // for debugging purposes
    GUM_DESTRUCTOR(Tensor)
  }

References Tensor().

Here is the call graph for this function:

Member Function Documentation

◆ abs()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::abs ( ) const

Apply abs on every element of the container.

Definition at line 379 of file tensor_tpl.h.

                                                                     {
    this->apply([](GUM_SCALAR x) {
      if (x >= 0) return x;
      else return -x;
    });
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::apply().

Here is the call graph for this function:

◆ add()

template<typename GUM_SCALAR>

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

finalvirtualinherited

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

See also: operator<<(MultiDimInterface& c, const DiscreteVariable& v)

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

Parameters

v	The new var.

Exceptions

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

Implements gum::MultiDimInterface.

Definition at line 188 of file multiDimDecorator_tpl.h.

                                                                            {
    if (v.domainSize() < 1) {
      GUM_ERROR(InvalidArgument, "Empty variable " << v << " cannot be added in a Tensor")
    }
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->add(v);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), add(), content_, gum::DiscreteVariable::domainSize(), and GUM_ERROR.

Referenced by gum::Tensor< GUM_SCALAR >::Tensor(), gum::Tensor< GUM_SCALAR >::Tensor(), add(), gum::Tensor< GUM_SCALAR >::evEq(), gum::Tensor< GUM_SCALAR >::evGt(), gum::Tensor< GUM_SCALAR >::evIn(), and gum::Tensor< GUM_SCALAR >::evLt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Apply a function on every element of the container.

Parameters

f	the function to apply

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 338 of file multiDimDecorator_tpl.h.

                                                                                           {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->empty()) {
      empty_value_ = f(empty_value_);
    } else {
      content_->apply(f);
    }
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, empty(), and empty_value_.

Referenced by gum::Tensor< GUM_SCALAR >::abs(), gum::Tensor< GUM_SCALAR >::inverse(), gum::Tensor< GUM_SCALAR >::log2(), gum::Tensor< GUM_SCALAR >::normalize(), gum::Tensor< GUM_SCALAR >::scale(), gum::Tensor< GUM_SCALAR >::sgn(), gum::Tensor< GUM_SCALAR >::sq(), and gum::Tensor< GUM_SCALAR >::translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ argmax()

template<typename GUM_SCALAR>

INLINE std::pair< Set< Instantiation >, GUM_SCALAR > gum::Tensor< GUM_SCALAR >::argmax ( ) const

Pair of the set of instantiation corresponding to the max and this max in the Tensor.

Definition at line 732 of file tensor_tpl.h.

                                                                                        {
    auto m = max();
    return std::pair(findAll(m), m);
  }

References findAll(), and max().

Here is the call graph for this function:

◆ argmin()

template<typename GUM_SCALAR>

INLINE std::pair< Set< Instantiation >, GUM_SCALAR > gum::Tensor< GUM_SCALAR >::argmin ( ) const

Pair of the set of instantiation corresponding to the min and this min in the Tensor.

Definition at line 739 of file tensor_tpl.h.

                                                                                        {
    auto m = min();
    return std::pair(findAll(m), m);
  }

References findAll(), and min().

Here is the call graph for this function:

◆ beginMultipleChanges()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Default implementation of MultiDimContainer::set().

Calls get_ as a r-value.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 371 of file multiDimDecorator_tpl.h.

                                                                    {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->beginMultipleChanges();
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), beginMultipleChanges(), and content_.

Referenced by gum::Tensor< GUM_SCALAR >::Tensor(), and beginMultipleChanges().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ changeNotification()

template<typename GUM_SCALAR>

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

finalvirtualinherited

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 198 of file multiDimDecorator_tpl.h.

                                                                              {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->changeNotification(i,
                                                                                  var,
                                                                                  oldval,
                                                                                  newval);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), changeNotification(), and content_.

Referenced by changeNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ complementVars_()

template<typename GUM_SCALAR>

gum::VariableSet gum::Tensor< GUM_SCALAR >::complementVars_ ( const gum::VariableSet & del_vars ) const

nodiscardprotected

Definition at line 607 of file tensor_tpl.h.

                                                                                       {
    gum::VariableSet cplt;
 
    for (const auto x: this->variablesSequence())
      if (!vars.contains(x)) cplt.insert(x);
 
    return cplt;
  }

References gum::Set< Key >::contains(), gum::Set< Key >::insert(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

Referenced by maxIn(), minIn(), prodIn(), and sumIn().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ contains()

template<typename GUM_SCALAR>

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

finalvirtualinherited

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 277 of file multiDimDecorator_tpl.h.

                                                                                         {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->contains(var);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), contains(), and content_.

Referenced by contains(), gum::Tensor< GUM_SCALAR >::KL(), gum::Tensor< GUM_SCALAR >::putFirst(), and gum::Tensor< GUM_SCALAR >::reorganize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ content() [1/2]

template<typename GUM_SCALAR>

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

finalvirtualinherited

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 366 of file multiDimDecorator_tpl.h.

                                                              {
    return content_;
  }

References content_.

Here is the caller graph for this function:

◆ content() [2/2]

template<typename GUM_SCALAR>

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

finalvirtualinherited

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 359 of file multiDimDecorator_tpl.h.

                                                                                        {
    return content_;
  }

References content_.

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

◆ deterministicTensor() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::deterministicTensor	(	const DiscreteVariable &	var,
		const std::string &	label )

static

Definition at line 1172 of file tensor_tpl.h.

                                                                                              {
    return Tensor< GUM_SCALAR >::deterministicTensor(var, var.index(value));
  }

References deterministicTensor(), and gum::DiscreteVariable::index().

Here is the call graph for this function:

◆ deterministicTensor() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::deterministicTensor	(	const DiscreteVariable &	var,
		Idx	value )

static

Definition at line 1156 of file tensor_tpl.h.

                                                                                                {
    Tensor< GUM_SCALAR > pot;
 
    pot.beginMultipleChanges();
    pot << var;
    pot.endMultipleChanges(GUM_SCALAR(0.0));
 
    Instantiation I(pot);
    I.chgVal(var, value);
    pot.set(I, GUM_SCALAR(1.0));
 
    return pot;
  }

References gum::Instantiation::chgVal().

Referenced by gum::BayesNet< double >::_clearTensors_(), gum::GraphicalModelInference< GUM_SCALAR >::_createHardEvidence_(), and deterministicTensor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ domainSize()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Returns the product of the variables domain size.

Returns: Returns the product of the variables domain size.

Implements gum::MultiDimInterface.

Definition at line 181 of file multiDimDecorator_tpl.h.

                                                                {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->domainSize();
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and domainSize().

Referenced by domainSize(), gum::SimpleUTGenerator::generateUT(), gum::SimpleUTGenerator::generateUT(), gum::InfluenceDiagram< GUM_SCALAR >::operator==(), gum::Tensor< GUM_SCALAR >::random(), gum::Tensor< GUM_SCALAR >::randomCPT(), and gum::Tensor< GUM_SCALAR >::randomDistribution().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw()

template<typename GUM_SCALAR>

Idx gum::Tensor< GUM_SCALAR >::draw ( ) const

nodiscard

get a value at random from a 1-D distribution

Definition at line 696 of file tensor_tpl.h.

                                       {
    if (this->nbrDim() != 1) {
      GUM_ERROR(FatalError, "To draw from a tensor, the dimension must be 1")
    }
 
    auto          r = static_cast< GUM_SCALAR >(randomProba());
    Instantiation Ip(*this);
    for (Ip.setFirst(); !Ip.end(); Ip.inc()) {
      r -= this->get(Ip);
      if (r <= 0) return Ip.val(0);
    }
    return this->variable(0).domainSize() - 1;
  }

References gum::Instantiation::end(), gum::MultiDimDecorator< GUM_SCALAR >::get(), GUM_ERROR, gum::Instantiation::inc(), gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), gum::randomProba(), gum::Instantiation::setFirst(), gum::Instantiation::val(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

Referenced by gum::GibbsOperator< GUM_SCALAR >::_GibbsSample_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ empty()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Returns true if no var is in *this.

Returns: Returns true if no var is in *this.

Implements gum::MultiDimInterface.

Definition at line 282 of file multiDimDecorator_tpl.h.

                                                           {
    if (content_ == nullptr) return true;
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->empty();
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and empty().

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::MultiDimDecorator< GUM_SCALAR >::endMultipleChanges ( )

finalvirtualinherited

Default implementation of MultiDimContainer::set().

Calls get_ as a r-value.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 376 of file multiDimDecorator_tpl.h.

                                                                  {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->endMultipleChanges();
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and endMultipleChanges().

Referenced by gum::Tensor< GUM_SCALAR >::Tensor(), endMultipleChanges(), endMultipleChanges(), and newFactory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endMultipleChanges() [2/2]

template<typename GUM_SCALAR>

INLINE void gum::MultiDimDecorator< GUM_SCALAR >::endMultipleChanges ( const GUM_SCALAR & x )

finalvirtualinherited

Default implementation of MultiDimContainer::set().

Calls get_ as a r-value.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 381 of file multiDimDecorator_tpl.h.

                                                                                     {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->endMultipleChanges(x);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and endMultipleChanges().

Here is the call graph for this function:

◆ entropy()

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::Tensor< GUM_SCALAR >::entropy ( ) const

entropy of the Tensor

Definition at line 250 of file tensor_tpl.h.

                                                        {
    return -this->expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      return GUM_SCALAR(GUM_LOG2_OR_0(this->get(i)));
    });
  }

References expectedValue(), gum::MultiDimDecorator< GUM_SCALAR >::get(), and GUM_LOG2_OR_0.

Here is the call graph for this function:

◆ erase() [1/2]

template<typename GUM_SCALAR>

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

finalvirtualinherited

Removes a var from the variables of the multidimensional matrix.

See also: operator>>(MultiDimInterface& c, const DiscreteVariable& v)

Exceptions

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

Implements gum::MultiDimInterface.

Definition at line 251 of file multiDimDecorator_tpl.h.

                                                                                {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->erase(var);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and erase().

Referenced by erase(), and erase().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ erase() [2/2]

template<typename GUM_SCALAR>

INLINE void gum::MultiDimDecorator< GUM_SCALAR >::erase ( const std::string & name )

finalvirtualinherited

Definition at line 256 of file multiDimDecorator_tpl.h.

                                                                          {
    erase(variable(name));
  }

References erase(), and variable().

Here is the call graph for this function:

◆ evEq()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::evEq	(	const DiscreteVariable &	v,
		double	val )

static

numerical evidence generator

Definition at line 1085 of file tensor_tpl.h.

                                                                                       {
    const auto i = v.closestIndex(val);
 
    gum::Tensor< GUM_SCALAR > p;
    p.add(v);
    p.fillWith(0);
    Instantiation I(p);
    I.chgVal(0, i);
    p.set(I, 1);
    return p;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::add(), gum::Instantiation::chgVal(), gum::DiscreteVariable::closestIndex(), fillWith(), and gum::MultiDimDecorator< GUM_SCALAR >::set().

Referenced by gum::IBayesNet< GUM_SCALAR >::evEq(), evGt(), and evLt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ evGt()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::evGt	(	const DiscreteVariable &	v,
		double	val )

static

numerical evidence generator

Definition at line 1119 of file tensor_tpl.h.

                                                                                       {
    const auto i = v.closestIndex(val);
    if (i == v.domainSize() - 1) { return evEq(v, val); }
 
    gum::Tensor< GUM_SCALAR > p;
    p.add(v);
    p.fillWith(0);
    Instantiation I(p);
    for (Idx i2 = i + 1; i2 < v.domainSize(); i2++) {
      I.chgVal(0, i2);
      p.set(I, 1);
    }
    return p;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::add(), gum::Instantiation::chgVal(), gum::DiscreteVariable::closestIndex(), gum::DiscreteVariable::domainSize(), evEq(), fillWith(), and gum::MultiDimDecorator< GUM_SCALAR >::set().

Referenced by gum::IBayesNet< GUM_SCALAR >::evGt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ evIn()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::evIn	(	const DiscreteVariable &	v,
		double	val1,
		double	val2 )

static

numerical evidence generator

Definition at line 1099 of file tensor_tpl.h.

                                                                                    {
    if (val2 < val1) {
      GUM_ERROR(InvalidArgument,
                "val2 (" << val2 << ") must be greater than val1 (" << val1 << ").")
    }
    const auto i1 = v.closestIndex(val1);
    const auto i2 = v.closestIndex(val2);
 
    gum::Tensor< GUM_SCALAR > p;
    p.add(v);
    p.fillWith(0);
    Instantiation I(p);
    for (Idx i = i1; i <= i2; i++) {
      I.chgVal(0, i);
      p.set(I, 1);
    }
    return p;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::add(), gum::Instantiation::chgVal(), gum::DiscreteVariable::closestIndex(), fillWith(), GUM_ERROR, and gum::MultiDimDecorator< GUM_SCALAR >::set().

Referenced by gum::IBayesNet< GUM_SCALAR >::evIn().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ evLt()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::evLt	(	const DiscreteVariable &	v,
		double	val )

static

numerical evidence generator

Definition at line 1135 of file tensor_tpl.h.

                                                                                       {
    const auto i = v.closestIndex(val);
    if (i == 0) { return evEq(v, val); }
 
    gum::Tensor< GUM_SCALAR > p;
    p.add(v);
    p.fillWith(0);
    Instantiation I(p);
    for (Idx i2 = 0; i2 < i; i2++) {
      I.chgVal(0, i2);
      p.set(I, 1);
    }
    return p;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::add(), gum::Instantiation::chgVal(), gum::DiscreteVariable::closestIndex(), evEq(), fillWith(), and gum::MultiDimDecorator< GUM_SCALAR >::set().

Referenced by gum::IBayesNet< GUM_SCALAR >::evLt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ expectedValue()

template<typename GUM_SCALAR>

GUM_SCALAR gum::Tensor< GUM_SCALAR >::expectedValue ( std::function< GUM_SCALAR(const gum::Instantiation &) > f ) const

ExpectedValue computes the expectation of f over *this.

Warnings

ExpectedValue assumes (and does not check) that the Tensor contains a joint distribution.

Definition at line 233 of file tensor_tpl.h.

                                                                  {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return static_cast< GUM_SCALAR >(0);
    }
 
    GUM_SCALAR res = 0;
    auto       i   = Instantiation(*this);
    for (i.setFirst(); !i.end(); i.inc()) {
      const GUM_SCALAR v_f = f(i);
      if (v_f != GUM_SCALAR(0.0)) res += this->get(i) * v_f;
    }
    return res;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), and gum::MultiDimDecorator< GUM_SCALAR >::get().

Referenced by entropy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extract()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::extract ( const Instantiation & inst ) const

create a new Tensor extracted from *this given a partial instantiation

Definition at line 688 of file tensor_tpl.h.

                                                                                    {
    Tensor< GUM_SCALAR > p;
    p.extractFrom(*this, inst);
 
    return p;
  }

◆ 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::MultiDimDecorator< GUM_SCALAR >::fill ( const GUM_SCALAR & d ) const

finalvirtualinherited

Default implementation of MultiDimContainer::set().

Calls get_ as a r-value.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 293 of file multiDimDecorator_tpl.h.

                                                                             {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->empty()) {
      empty_value_ = d;
    } else {
      static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->fill(d);
    }
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, empty(), empty_value_, and fill().

Referenced by fill(), and gum::Tensor< GUM_SCALAR >::fillWith().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fillWith() [1/4]

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::fillWith ( const GUM_SCALAR & val ) const

Automatically fills this MultiDimContainer with the value v.

Parameters

v	contains the data.

Definition at line 264 of file tensor_tpl.h.

                                                                                               {
    this->fill(val);
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::fill().

Here is the call graph for this function:

◆ fillWith() [2/4]

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::fillWith ( const std::vector< GUM_SCALAR > & data ) const

Automatically fills the tensor with the values in v.

Parameters

v	Vector of values.

Exceptions

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

Definition at line 258 of file tensor_tpl.h.

                                                                                       {
    this->populate(data);
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::populate().

Here is the call graph for this function:

◆ fillWith() [3/4]

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::fillWith ( const Tensor< GUM_SCALAR > & src ) const

copy a Tensor data using name of variables and labels (not necessarily the same variables in the same orders)

Warning: a strict control on names of variables and labels are made

Exceptions

InvalidArgument if the Tensor is not compatible with this

Definition at line 271 of file tensor_tpl.h.

                                                                                   {
    if (src.domainSize() != this->domainSize()) {
      GUM_ERROR(InvalidArgument, "Tensor to copy has not the same domainSize.")
    }
    gum::Set< std::string > son;   // set of names
    for (const auto& v: src.variablesSequence()) {
      son.insert(v->name());
    }
    for (const auto& v: this->variablesSequence()) {
      if (!son.contains(v->name())) {
        GUM_ERROR(InvalidArgument,
                  "Variable <" << v->name() << "> not present in src (" << son << ").")
      }
      // we check size, labels and order of labels in the same time
      if (v->toString() != src.variable(v->name()).toString()) {
        GUM_ERROR(InvalidArgument, "Variables <" << v->name() << "> are not identical.")
      }
    }
 
    Instantiation Isrc(src);
    Instantiation Idst(*this);
    for (Isrc.setFirst(); !Isrc.end(); ++Isrc) {
      for (Idx i = 0; i < this->nbrDim(); i++) {
        Idst.chgVal(Isrc.variable(i).name(), Isrc.val(i));
      }
      this->set(Idst, src.get(Isrc));
    }
 
    return *this;
  }

References gum::Instantiation::chgVal(), gum::Set< Key >::contains(), gum::Instantiation::end(), GUM_ERROR, gum::Set< Key >::insert(), gum::Variable::name(), gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), gum::MultiDimDecorator< GUM_SCALAR >::set(), gum::Instantiation::setFirst(), gum::Instantiation::val(), gum::Instantiation::variable(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

Referenced by gum::DecisionTensor< GUM_SCALAR >::clear(), evEq(), evGt(), evIn(), evLt(), noising(), random(), randomCPT(), and randomDistribution().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fillWith() [4/4]

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::fillWith	(	const Tensor< GUM_SCALAR > &	src,
		const std::vector< std::string > &	mapSrc ) const

copy a Tensor data using the sequence of names in mapSrc to find the corresponding variables.

For instance, to copy the tensor P(A,B,C) in Q(D,E,A) with the mapping P.A<->Q.E, P.B<->Q.A, P.C<->Q.D (assuming that the corresponding variables have the same domain size and the order of labels):

Q.fillWith(P,{"C","A","B"});

Warning: a strict control on names of variables and labels are made

Exceptions

InvalidArgument if the Tensor is not compatible with this

Definition at line 304 of file tensor_tpl.h.

                                                                                 {
    if (src.nbrDim() != this->nbrDim()) {
      GUM_ERROR(InvalidArgument, "Tensor to copy has not the same size.")
    }
    if (src.nbrDim() != mapSrc.size()) {
      GUM_ERROR(InvalidArgument, "Tensor and vector have not the same size.")
    }
    Instantiation Isrc;
    for (Idx i = 0; i < src.nbrDim(); i++) {
      if (src.variable(mapSrc[i]).domainSize() != this->variable(i).domainSize()) {
        GUM_ERROR(InvalidArgument,
                  "Variables " << mapSrc[i] << " (in the argument) and " << this->variable(i).name()
                               << " have not the same dimension.")
      } else {
        Isrc.add(src.variable(mapSrc[i]));
      }
    }
    Instantiation Idst(*this);
    for (Isrc.setFirst(); !Isrc.end(); ++Isrc, ++Idst) {
      this->set(Idst, src.get(Isrc));
    }
 
    return *this;
  }

References gum::Instantiation::add(), gum::Instantiation::end(), GUM_ERROR, gum::MultiDimDecorator< GUM_SCALAR >::set(), gum::Instantiation::setFirst(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

Here is the call graph for this function:

◆ findAll()

template<typename GUM_SCALAR>

Set< Instantiation > gum::Tensor< GUM_SCALAR >::findAll ( GUM_SCALAR v ) const

set of instantiation corresponding to the parameter v in the Tensor

Definition at line 718 of file tensor_tpl.h.

                                                                       {
    Instantiation        I(*this);
    Set< Instantiation > res;
 
    //    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) { return
    //    res; }
    for (I.setFirst(); !I.end(); ++I) {
      if (this->get(I) == v) res.insert(Instantiation(I, false));
    }
    return res;
  }

References gum::Instantiation::end(), gum::MultiDimDecorator< GUM_SCALAR >::get(), gum::Set< Key >::insert(), and gum::Instantiation::setFirst().

Referenced by argmax(), and argmin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Default implementation of MultiDimContainer::get().

Calls get_ as a l-value.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 160 of file multiDimDecorator_tpl.h.

                                                                                     {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->empty()) {
      return empty_value_;
    } else {
      return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->get(i);
    }
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, empty(), empty_value_, and get().

Referenced by gum::Tensor< GUM_SCALAR >::draw(), gum::Tensor< GUM_SCALAR >::entropy(), gum::Tensor< GUM_SCALAR >::expectedValue(), gum::Tensor< GUM_SCALAR >::findAll(), get(), gum::Tensor< GUM_SCALAR >::KL(), gum::Tensor< GUM_SCALAR >::normalizeAsCPT(), gum::InfluenceDiagram< GUM_SCALAR >::operator==(), gum::prm::o3prmr::O3prmrInterpreter::query(), and gum::Tensor< GUM_SCALAR >::toString().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_()

template<typename GUM_SCALAR>

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

finalprotectedvirtualinherited

Return a data, given a Instantiation - final method.

Parameters

i	The instantiation.

Exceptions

NullElement
NotFound

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 155 of file multiDimDecorator_tpl.h.

                                                                                       {
    GUM_ERROR(OperationNotAllowed, "_get in the implementation !")
  }

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:

◆ inverse()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::inverse ( ) const

the function to inverse (each value of) *this

Definition at line 449 of file tensor_tpl.h.

                                                                         {
    this->apply([](GUM_SCALAR x) { return 1 / x; });
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::apply().

Here is the call graph for this function:

◆ isEvidence()

template<typename GUM_SCALAR>

bool gum::Tensor< GUM_SCALAR >::isEvidence ( ) const

nodiscard

is an evidence ? (marginal-like but has not to sum to 1)

Definition at line 839 of file tensor_tpl.h.

                                              {
    if (this->nbrDim() != 1) return false;
    if (this->sum() <= 0.0) return false;
    return (this->min() >= 0.0) && (this->max() <= 1.0);
  }

References max(), min(), gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), and sum().

Referenced by operator&(), operator|(), and operator~().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isNonZeroMap()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::isNonZeroMap ( ) const

create a boolean-like tensor using the predicate isNonZero

Definition at line 597 of file tensor_tpl.h.

                                                                       {
    auto p = Tensor< GUM_SCALAR >(*this);
    p.apply([](GUM_SCALAR x) {
      if (x != static_cast< GUM_SCALAR >(0)) return static_cast< GUM_SCALAR >(1);
      else return static_cast< GUM_SCALAR >(0);
    });
    return p;
  }

◆ KL()

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::Tensor< GUM_SCALAR >::KL ( const Tensor< GUM_SCALAR > & p ) const

compute KL divergence between this and p Checks the compatibility and then compute KL divergence

Exceptions

gum::InvalidArgument	if p is not compatible with $this (dimension, variables)
gum::FatalError	if a zero is found in p or this and not in the other.

Definition at line 349 of file tensor_tpl.h.

                                                                                {
    if (this->nbrDim() != p.nbrDim())
      GUM_ERROR(InvalidArgument, "BNdistance between tensors with different numbers of dimensions")
    for (const auto var: p.variablesSequence()) {
      if (!this->contains(*var))
        GUM_ERROR(InvalidArgument, "A variable in the argument does not belong to the tensor.")
    }
    for (const auto var: this->variablesSequence()) {
      if (!p.contains(*var))
        GUM_ERROR(InvalidArgument, "A variable does not belong to the argument.")
    }
 
    Instantiation inst(*this);
    auto          res = static_cast< GUM_SCALAR >(0);
    for (inst.setFirst(); !inst.end(); inst.inc()) {
      GUM_SCALAR x = this->get(inst);
      GUM_SCALAR y = p.get(inst);
      if (static_cast< GUM_SCALAR >(0) == x)   // 0*log(0/y)=0
        continue;
 
      if (static_cast< GUM_SCALAR >(0) == y)
        // we know that x!=0;
        GUM_ERROR(FatalError, "The argument has a 0 at " << inst << " while the tensor has not.")
 
      res += x * std::log2(x / y);
    }
    return res;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::contains(), gum::Instantiation::end(), gum::MultiDimDecorator< GUM_SCALAR >::get(), GUM_ERROR, gum::Instantiation::inc(), gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), gum::Instantiation::setFirst(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

Here is the call graph for this function:

◆ log2()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::log2 ( ) const

apply $log_2(x)$ on every element of the container

Definition at line 337 of file tensor_tpl.h.

                                                                      {
    this->apply([](GUM_SCALAR x) { return std::log2(x); });
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::apply().

Here is the call graph for this function:

◆ max()

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::Tensor< GUM_SCALAR >::max ( ) const

max of all elements in the Tensor

Definition at line 175 of file tensor_tpl.h.

                                                    {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return this->empty_value_;
    }
    return gum::projectMax(*this->content());
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, and gum::projectMax().

Referenced by argmax(), isEvidence(), maxIn(), and maxOut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ maxIn()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::maxIn ( const gum::VariableSet & kept_vars ) const

Projection using max as operation (and implementation-optimized operations).

Parameters

kept_vars is the set of vars to keep

Definition at line 584 of file tensor_tpl.h.

                                                                                               {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return Tensor< GUM_SCALAR >().fillWith(this->empty_value_);
    }
 
    // if kept_var is empty, create an empty tensor
    // TODO: remove this test when operations will be able to handle empty tensors
    if (kept_vars.empty()) { return Tensor< GUM_SCALAR >().fillWith(this->max()); }
 
    return Tensor< GUM_SCALAR >(gum::projectMax(*this->content(), complementVars_(kept_vars)));
  }

References complementVars_(), gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::Set< Key >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, max(), and gum::projectMax().

Here is the call graph for this function:

◆ maxNonOne()

template<typename GUM_SCALAR>

GUM_SCALAR gum::Tensor< GUM_SCALAR >::maxNonOne ( ) const

max of all non one elements in the Tensor

Warning: can return 1 if no other value than 1 ...

Definition at line 194 of file tensor_tpl.h.

                                                   {
    GUM_SCALAR res;
 
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      res = this->empty_value_;
    } else {
      res = this->reduce(
          [](GUM_SCALAR z, GUM_SCALAR p) {
            return (p == static_cast< GUM_SCALAR >(1)) ? z
                 : (z == static_cast< GUM_SCALAR >(1)) ? p
                                                       : (p > z ? p : z);
          },
          static_cast< GUM_SCALAR >(1));
    }
 
    return res;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, and gum::MultiDimDecorator< GUM_SCALAR >::reduce().

Here is the call graph for this function:

◆ maxOut()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::maxOut ( const gum::VariableSet & del_vars ) const

Projection using max as operation (and implementation-optimized operations).

Parameters

del_vars is the set of vars to eliminate

Definition at line 522 of file tensor_tpl.h.

                                                                                               {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return Tensor< GUM_SCALAR >().fillWith(this->empty_value_);
    }
 
    // if we remove all the variables, create an empty tensor
    // TODO: remove this test when operations will be able to handle empty tensors
    if (this->variablesSequence().size() <= del_vars.size()) {
      bool equal = true;
      for (const auto var: this->variablesSequence()) {
        if (!del_vars.exists(var)) {
          equal = false;
          break;
        }
      }
      if (equal) { return Tensor< GUM_SCALAR >().fillWith(this->max()); }
    }
 
    return Tensor< GUM_SCALAR >(gum::projectMax(*this->content(), del_vars));
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, gum::Set< Key >::exists(), max(), gum::projectMax(), gum::Set< Key >::size(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

Here is the call graph for this function:

◆ memoryFootprint()

template<typename GUM_SCALAR>

Size gum::Tensor< GUM_SCALAR >::memoryFootprint ( ) const

compute the (approximated) footprint in memory of the tensor

Returns: the size in bytes

Definition at line 1151 of file tensor_tpl.h.

                                                   {
    return this->content()->realSize() * sizeof(GUM_SCALAR);
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content().

Here is the call graph for this function:

◆ min()

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::Tensor< GUM_SCALAR >::min ( ) const

min of all elements in the Tensor

Definition at line 184 of file tensor_tpl.h.

                                                    {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return this->empty_value_;
    }
    return gum::projectMin(*this->content());
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, and gum::projectMin().

Referenced by argmin(), isEvidence(), minIn(), and minOut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minIn()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::minIn ( const gum::VariableSet & kept_vars ) const

Projection using min as operation (and implementation-optimized operations).

Parameters

kept_vars is the set of vars to keep

Definition at line 571 of file tensor_tpl.h.

                                                                                               {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return Tensor< GUM_SCALAR >().fillWith(this->empty_value_);
    }
 
    // if kept_var is empty, create an empty tensor
    // TODO: remove this test when operations will be able to handle empty tensors
    if (kept_vars.empty()) { return Tensor< GUM_SCALAR >().fillWith(this->min()); }
 
    return Tensor< GUM_SCALAR >(gum::projectMin(*this->content(), complementVars_(kept_vars)));
  }

References complementVars_(), gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::Set< Key >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, min(), and gum::projectMin().

Here is the call graph for this function:

◆ minNonZero()

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::Tensor< GUM_SCALAR >::minNonZero ( ) const

min of all non zero elements in the Tensor

Warning: can return 0 if no other value than 0 ...

Definition at line 215 of file tensor_tpl.h.

                                                           {
    GUM_SCALAR res;
 
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      res = this->empty_value_;
    } else {
      res = this->reduce(
          [](GUM_SCALAR z, GUM_SCALAR p) {
            return (p == static_cast< GUM_SCALAR >(0)) ? z
                 : (z == static_cast< GUM_SCALAR >(0)) ? p
                                                       : (p < z ? p : z);
          },
          static_cast< GUM_SCALAR >(0));
    }
    return res;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, and gum::MultiDimDecorator< GUM_SCALAR >::reduce().

Here is the call graph for this function:

◆ minOut()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::minOut ( const gum::VariableSet & del_vars ) const

Projection using min as operation (and implementation-optimized operations).

Parameters

del_vars is the set of vars to eliminate

Definition at line 500 of file tensor_tpl.h.

                                                                                               {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return Tensor< GUM_SCALAR >().fillWith(this->empty_value_);
    }
 
    // if we remove all the variables, create an empty tensor
    // TODO: remove this test when operations will be able to handle empty tensors
    if (this->variablesSequence().size() <= del_vars.size()) {
      bool equal = true;
      for (const auto var: this->variablesSequence()) {
        if (!del_vars.exists(var)) {
          equal = false;
          break;
        }
      }
      if (equal) { return Tensor< GUM_SCALAR >().fillWith(this->min()); }
    }
 
    return Tensor< GUM_SCALAR >(gum::projectMin(*this->content(), del_vars));
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, gum::Set< Key >::exists(), min(), gum::projectMin(), gum::Set< Key >::size(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

Here is the call graph for this function:

◆ nbrDim()

template<typename GUM_SCALAR>

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

finalvirtualinherited

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

                                                           {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->nbrDim();
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and nbrDim().

Referenced by gum::GibbsOperator< GUM_SCALAR >::_GibbsSample_(), gum::Tensor< GUM_SCALAR >::draw(), gum::Tensor< GUM_SCALAR >::fillWith(), gum::Tensor< GUM_SCALAR >::isEvidence(), gum::Tensor< GUM_SCALAR >::KL(), nbrDim(), gum::Tensor< GUM_SCALAR >::normalizeAsCPT(), gum::InfluenceDiagram< GUM_SCALAR >::operator==(), gum::Tensor< GUM_SCALAR >::putFirst(), gum::Tensor< GUM_SCALAR >::putFirst(), gum::Tensor< GUM_SCALAR >::reorganize(), and set().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_abs()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::new_abs ( ) const

Create a new tensor and apply abs on every element of the container.

Definition at line 797 of file tensor_tpl.h.

                                                           {
    return Tensor< GUM_SCALAR >(*this).abs();
  }

◆ new_log2()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::new_log2 ( ) const

Create a new tensor and apply $log_2(x)$ on every element of the container.

Definition at line 807 of file tensor_tpl.h.

                                                            {
    return Tensor< GUM_SCALAR >(*this).log2();
  }

◆ new_sgn()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::new_sgn ( ) const

Create a new tensor and apply sgn(x)$ on every element of the container.

fill the tensor with -1 for a GUM_SCALAR<0,1 if >0 and 0 if ==0

Definition at line 812 of file tensor_tpl.h.

                                                           {
    return Tensor< GUM_SCALAR >(*this).sgn();
  }

◆ new_sq()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::new_sq ( ) const

Create a new tensor and apply $x^2$ on every element of the container.

Definition at line 802 of file tensor_tpl.h.

                                                          {
    return Tensor< GUM_SCALAR >(*this).sq();
  }

◆ newFactory()

template<typename GUM_SCALAR>

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

finalvirtual

Default implementation of MultiDimContainer::set().

Calls get_ as a r-value.

Implements gum::MultiDimDecorator< GUM_SCALAR >.

Definition at line 150 of file tensor_tpl.h.

                                                                      {
    return new Tensor< GUM_SCALAR >(
        static_cast< MultiDimImplementation< GUM_SCALAR >* >(this->content()->newFactory()));
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), and newFactory().

Referenced by Tensor(), and newFactory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ noising()

template<typename GUM_SCALAR>

const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::noising ( GUM_SCALAR alpha ) const

add a noise in a CPT by mixing (1-alpha)this+alpha.randomCPT()

Warning: alpha in [0,1]

Definition at line 788 of file tensor_tpl.h.

                                                                                  {
    if ((alpha < GUM_SCALAR(0.0)) || (alpha > GUM_SCALAR(1.0))) {
      GUM_ERROR(InvalidArgument, "alpha must be in [0,1]")
    }
    Tensor< GUM_SCALAR > noise(*this);
    return fillWith(scale(1 - alpha) + noise.randomCPT().scale(alpha)).normalizeAsCPT();
  }

References fillWith(), GUM_ERROR, and scale().

Here is the call graph for this function:

◆ normalize()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::normalize ( ) const

normalisation of this do nothing if sum is 0

Definition at line 390 of file tensor_tpl.h.

                                                                           {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      if (this->empty_value_ != static_cast< GUM_SCALAR >(0))
        this->empty_value_ = static_cast< GUM_SCALAR >(1.0);
    } else {
      GUM_SCALAR s = sum();
 
      if (s != (GUM_SCALAR)0) {
        this->apply([s](GUM_SCALAR x) { return x / s; });
      }
    }
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::apply(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, and sum().

Referenced by gum::GibbsOperator< GUM_SCALAR >::_GibbsSample_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ normalizeAsCPT()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::normalizeAsCPT ( const Idx & varId = 0 ) const

normalisation of this as a CPT for the variable varId

If the Tensor is empty, the argument is not used.

Exceptions

FatalError it some distribution sums to 0, or if varId>=nbrDim()

Definition at line 405 of file tensor_tpl.h.

                                                                                                {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      if (this->empty_value_ != static_cast< GUM_SCALAR >(0)) {
        this->empty_value_ = static_cast< GUM_SCALAR >(1.0);
      } else {
        GUM_ERROR(FatalError, "Normalization for a tensor that sum to 0 in " << *this)
      }
    } else {
      if (varId >= this->nbrDim()) {
        GUM_ERROR(FatalError, varId << " is not a position for " << *this)
      }
      Instantiation inst(*this);
      const auto&   v = this->variable(varId);
 
      for (inst.setFirst(); !inst.end(); inst.incNotVar(v)) {
        auto s = (GUM_SCALAR)0.0;
        for (inst.setFirstVar(v); !inst.end(); inst.incVar(v))
          s += this->get(inst);
        if (s == (GUM_SCALAR)0.0) {
          GUM_ERROR(FatalError, "Normalization for a tensor that sum to 0 in " << *this)
        }
        if (s != (GUM_SCALAR)1.0) {
          for (inst.setFirstVar(v); !inst.end(); inst.incVar(v))
            this->set(inst, this->get(inst) / s);
        }
        inst.setFirstVar(v);   // to remove inst.end()
      }
    }
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, gum::Instantiation::end(), gum::MultiDimDecorator< GUM_SCALAR >::get(), GUM_ERROR, gum::Instantiation::incNotVar(), gum::Instantiation::incVar(), gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), gum::MultiDimDecorator< GUM_SCALAR >::set(), gum::Instantiation::setFirst(), gum::Instantiation::setFirstVar(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

Here is the call graph for this function:

◆ notifyChange()

template<typename GUM_SCALAR>

INLINE void gum::MultiDimDecorator< GUM_SCALAR >::notifyChange ( ) const

finalvirtualinherited

Definition at line 304 of file multiDimDecorator_tpl.h.

                                                                  {
    /*( (MultiDimContainer<GUM_SCALAR> *) content_)->notifyChange();*/
    GUM_ERROR(OperationNotAllowed, "Not implemented yet")
  }

References GUM_ERROR.

◆ 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>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator& ( const Tensor< GUM_SCALAR > & p2 ) const

the function to be used to add two Tensors

Definition at line 862 of file tensor_tpl.h.

                                                                                           {
    if (!isEvidence() || !p2.isEvidence())
      GUM_ERROR(InvalidArgument, "The tensors are not evidences.")
    if (this->variable(0) != p2.variable(0))
      GUM_ERROR(InvalidArgument, "The evidence are not on the same variable.")
    Tensor< GUM_SCALAR > res(*this);
    gum::Instantiation   I(res);
    for (I.setFirst(); !I.end(); ++I) {
      res.set(I, std::min(res.get(I), p2.get(I)));
    }
    return res;
  }

References gum::Instantiation::end(), GUM_ERROR, isEvidence(), gum::Instantiation::setFirst(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

Here is the call graph for this function:

◆ operator*() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator* ( const GUM_SCALAR & v ) const

the function to be used to multiply a Tensor and a scalar

Definition at line 917 of file tensor_tpl.h.

                                                                                {
    return Tensor< GUM_SCALAR >(*this).scale(v);
  }

◆ operator*() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator* ( const Tensor< GUM_SCALAR > & p2 ) const

the function to be used to multiply two Tensors

Definition at line 908 of file tensor_tpl.h.

                                                                                           {
    if (p2.empty()) return Tensor< GUM_SCALAR >(*this).scale(p2.empty_value_);
    if (this->empty()) return Tensor< GUM_SCALAR >(p2).scale(this->empty_value_);
 
    return Tensor< GUM_SCALAR >(*this->content() * *p2.content());
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::empty(), and gum::MultiDimDecorator< GUM_SCALAR >::empty_value_.

Here is the call graph for this function:

◆ operator*=() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator*= ( const GUM_SCALAR & v )

the function to be used to add two Tensors

Definition at line 958 of file tensor_tpl.h.

                                                                          {
    this->scale(v);
    return *this;
  }

References scale().

Here is the call graph for this function:

◆ operator*=() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator*= ( const Tensor< GUM_SCALAR > & r )

the function to be used to add two Tensors

Definition at line 952 of file tensor_tpl.h.

                                                                                    {
    *this = *this * r;
    return *this;
  }

◆ operator+() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator+ ( const GUM_SCALAR & v ) const

the function to be used to add a GUM_SCALAR to a Tensor

Definition at line 833 of file tensor_tpl.h.

                                                                                {
    return Tensor< GUM_SCALAR >(*this).translate(v);
  }

◆ operator+() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator+ ( const Tensor< GUM_SCALAR > & p2 ) const

the function to be used to add two Tensors

Definition at line 824 of file tensor_tpl.h.

                                                                                           {
    if (p2.empty()) return Tensor< GUM_SCALAR >(*this).translate(p2.empty_value_);
    if (this->empty()) return Tensor< GUM_SCALAR >(p2).translate(this->empty_value_);
 
    return Tensor< GUM_SCALAR >(*this->content() + *p2.content());
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::empty(), and gum::MultiDimDecorator< GUM_SCALAR >::empty_value_.

Here is the call graph for this function:

◆ operator+=() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator+= ( const GUM_SCALAR & v )

the function to be used to add two Tensors

Definition at line 946 of file tensor_tpl.h.

                                                                          {
    this->translate(v);
    return *this;
  }

References translate().

Here is the call graph for this function:

◆ operator+=() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator+= ( const Tensor< GUM_SCALAR > & r )

the function to be used to add two Tensors

Definition at line 940 of file tensor_tpl.h.

                                                                                    {
    *this = *this + r;
    return *this;
  }

◆ operator-() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator- ( const GUM_SCALAR & v ) const

the function to be used to substract a GUM_SCALAR from a Tensor

Definition at line 902 of file tensor_tpl.h.

                                                                                {
    return Tensor< GUM_SCALAR >(*this).translate(-v);
  }

◆ operator-() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator- ( const Tensor< GUM_SCALAR > & p2 ) const

the function to be used to subtract two Tensors

Definition at line 890 of file tensor_tpl.h.

                                                                                           {
    if (p2.empty()) return Tensor< GUM_SCALAR >(*this).translate(-p2.empty_value_);
    if (this->empty()) {
      auto p = Tensor< GUM_SCALAR >(p2);
      p.apply([this](GUM_SCALAR x) { return this->empty_value_ - x; });
      return p;
    }
    return Tensor< GUM_SCALAR >(*this->content() - *p2.content());
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::empty(), and gum::MultiDimDecorator< GUM_SCALAR >::empty_value_.

Here is the call graph for this function:

◆ operator-=() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator-= ( const GUM_SCALAR & v )

the function to be used to add two Tensors

Definition at line 970 of file tensor_tpl.h.

                                                                          {
    this->translate(-v);
    return *this;
  }

References translate().

Here is the call graph for this function:

◆ operator-=() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator-= ( const Tensor< GUM_SCALAR > & r )

the function to be used to add two Tensors

Definition at line 964 of file tensor_tpl.h.

                                                                                    {
    *this = *this - r;
    return *this;
  }

◆ operator/() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator/ ( const GUM_SCALAR & v ) const

the function to be used to divide a Tensor by a scalar

Definition at line 935 of file tensor_tpl.h.

                                                                                {
    return Tensor< GUM_SCALAR >(*this).scale(1 / v);
  }

◆ operator/() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator/ ( const Tensor< GUM_SCALAR > & p2 ) const

the function to be used to divide two Tensors

Definition at line 923 of file tensor_tpl.h.

                                                                                           {
    if (p2.empty()) return Tensor< GUM_SCALAR >(*this).scale(1 / p2.empty_value_);
    if (this->empty()) {
      auto p = Tensor< GUM_SCALAR >(p2);
      p.apply([this](GUM_SCALAR x) { return this->empty_value_ / x; });
      return p;
    }
    return Tensor< GUM_SCALAR >(*this->content() / *p2.content());
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::empty(), and gum::MultiDimDecorator< GUM_SCALAR >::empty_value_.

Here is the call graph for this function:

◆ operator/=() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator/= ( const GUM_SCALAR & v )

the function to be used to add two Tensors

Definition at line 982 of file tensor_tpl.h.

                                                                          {
    this->scale(1 / v);
    return *this;
  }

References scale().

Here is the call graph for this function:

◆ operator/=() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator/= ( const Tensor< GUM_SCALAR > & r )

the function to be used to add two Tensors

Definition at line 976 of file tensor_tpl.h.

                                                                                    {
    *this = *this / r;
    return *this;
  }

◆ operator<<()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator<< ( const DiscreteVariable & v )

the function to be used to add two Tensors

Definition at line 812 of file tensor_tpl.h.

                                                                                  {
    this->add(v);
    return *this;
  }

◆ operator=() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator= ( const Tensor< GUM_SCALAR > & src )

Default constructor.

Creates an empty null dimensional matrix with a MultiDimArray as its implementation.

Definition at line 124 of file tensor_tpl.h.

                                                                                     {
    GUM_OP_CPY(Tensor)
    if (&src == this) return *this;
    MultiDimDecorator< GUM_SCALAR >::operator=(src);
    return *this;
  }

References Tensor(), and gum::MultiDimDecorator< GUM_SCALAR >::operator=().

Here is the call graph for this function:

◆ operator=() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::operator= ( Tensor< GUM_SCALAR > && src )

Default constructor.

Creates an empty null dimensional matrix with a MultiDimArray as its implementation.

Definition at line 133 of file tensor_tpl.h.

                                                                                {
    GUM_OP_MOV(Tensor)
    if (&src == this) return *this;
    MultiDimDecorator< GUM_SCALAR >::operator=(
        std::forward< MultiDimDecorator< GUM_SCALAR > >(src));
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::MultiDimDecorator(), Tensor(), and gum::MultiDimDecorator< GUM_SCALAR >::operator=().

Here is the call graph for this function:

◆ operator==() [1/2]

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==() [2/2]

template<typename GUM_SCALAR>

bool gum::Tensor< GUM_SCALAR >::operator== ( const Tensor< GUM_SCALAR > & r ) const

the function to be used to add two Tensors

Definition at line 988 of file tensor_tpl.h.

                                                                         {
    if (this->empty()) {
      if (r.empty()) return this->empty_value_ == r.empty_value_;
      else return false;
    } else {
      if (r.empty()) return false;
      else return (*this->content_) == (*r.content_);
    }
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), and gum::MultiDimDecorator< GUM_SCALAR >::empty_value_.

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:

◆ operator|()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator| ( const Tensor< GUM_SCALAR > & p2 ) const

the function to be used to add two Tensors

Definition at line 847 of file tensor_tpl.h.

                                                                                           {
    if (!isEvidence() || !p2.isEvidence())
      GUM_ERROR(InvalidArgument, "The tensors are not evidences.")
    if (this->variable(0) != p2.variable(0))
      GUM_ERROR(InvalidArgument, "The evidence are not on the same variable.")
    Tensor< GUM_SCALAR > res(*this);
    gum::Instantiation   I(res);
    for (I.setFirst(); !I.end(); ++I) {
      res.set(I, std::max(res.get(I), p2.get(I)));
    }
    return res;
  }

References gum::Instantiation::end(), GUM_ERROR, isEvidence(), gum::Instantiation::setFirst(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

Here is the call graph for this function:

◆ operator~()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::operator~ ( ) const

the function to be used to add two Tensors

Definition at line 877 of file tensor_tpl.h.

                                                             {
    if (!isEvidence()) GUM_ERROR(InvalidArgument, "The tensor is not an evidence.")
 
    Tensor< GUM_SCALAR > res(*this);
    gum::Instantiation   I(res);
    for (I.setFirst(); !I.end(); ++I) {
      res.set(I, 1 - res.get(I));
    }
    return res;
  }

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

Here is the call graph for this function:

◆ populate() [1/2]

template<typename GUM_SCALAR>

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

virtualinherited

Automatically fills this MultiDimContainer with the values in l.

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

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

Parameters

l	contains the data.

Exceptions

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

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

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

◆ populate() [2/2]

template<typename GUM_SCALAR>

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

finalvirtualinherited

Automatically fills this MultiDimContainer with the values in v.

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

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

Parameters

v	Vector of values.

Exceptions

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

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 325 of file multiDimDecorator_tpl.h.

                                                                                       {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->empty()) {
      if (v.size() == 1) {
        empty_value_ = v[0];
      } else {
        GUM_ERROR(SizeError, "Size do not match in populate")
      }
    } else {
      content_->populate(v);
    }
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, empty(), empty_value_, and GUM_ERROR.

Referenced by gum::Tensor< GUM_SCALAR >::fillWith(), gum::SimpleUTGenerator::generateUT(), and gum::SimpleUTGenerator::generateUT().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pos()

template<typename GUM_SCALAR>

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

finalvirtualinherited

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 272 of file multiDimDecorator_tpl.h.

                                                                                   {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->pos(var);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and pos().

Referenced by pos().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prodIn()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::prodIn ( const gum::VariableSet & kept_vars ) const

Projection using multiplication as operation (and implementation-optimized operations).

Parameters

kept_vars is the set of vars to keep

Definition at line 558 of file tensor_tpl.h.

                                                                           {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return Tensor< GUM_SCALAR >().fillWith(this->empty_value_);
    }
 
    // if kept_var is empty, create an empty tensor
    // TODO: remove this test when operations will be able to handle empty tensors
    if (kept_vars.empty()) { return Tensor< GUM_SCALAR >().fillWith(this->product()); }
 
    return Tensor< GUM_SCALAR >(gum::projectProduct(*this->content(), complementVars_(kept_vars)));
  }

References complementVars_(), gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::Set< Key >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, product(), and gum::projectProduct().

Here is the call graph for this function:

◆ prodOut()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::prodOut ( const gum::VariableSet & del_vars ) const

Projection using multiplication as operation (and implementation-optimized operations).

Parameters

del_vars is the set of vars to eliminate

Definition at line 478 of file tensor_tpl.h.

                                                                           {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return Tensor< GUM_SCALAR >().fillWith(this->empty_value_);
    }
 
    // if we remove all the variables, create an empty tensor
    // TODO: remove this test when operations will be able to handle empty tensors
    if (this->variablesSequence().size() <= del_vars.size()) {
      bool equal = true;
      for (const auto var: this->variablesSequence()) {
        if (!del_vars.exists(var)) {
          equal = false;
          break;
        }
      }
      if (equal) { return Tensor< GUM_SCALAR >().fillWith(this->product()); }
    }
 
    return Tensor< GUM_SCALAR >(gum::projectProduct(*this->content(), del_vars));
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, gum::Set< Key >::exists(), product(), gum::projectProduct(), gum::Set< Key >::size(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

Here is the call graph for this function:

◆ product()

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::Tensor< GUM_SCALAR >::product ( ) const

product of all elements in the Tensor

Definition at line 166 of file tensor_tpl.h.

                                                        {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return this->empty_value_;
    }
    return gum::projectProduct(*this->content());
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, and gum::projectProduct().

Referenced by prodIn(), and prodOut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ putFirst() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::putFirst ( const DiscreteVariable * var ) const

create a new Tensor with a certain variable in first

Exceptions

InvalidArgument if the var is not in the tensor

Definition at line 658 of file tensor_tpl.h.

                                                                                       {
    if (!this->contains(*var)) {
      GUM_ERROR(InvalidArgument, "The variable to put first does not belong to the tensor")
    }
    if (&(this->variable(0)) == var) return Tensor< GUM_SCALAR >(*this);
 
    std::vector< const DiscreteVariable* > vars;
    vars.push_back(var);
    for (Idx i = 0; i < this->nbrDim(); i++)
      if (&(this->variable(i)) != var) vars.push_back(&(this->variable(i)));
 
    return this->reorganize(vars);
  }

References gum::MultiDimDecorator< GUM_SCALAR >::contains(), GUM_ERROR, gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), reorganize(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

Referenced by putFirst().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ putFirst() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::putFirst ( const std::string & varname ) const

create a new Tensor with a certain variable in first

Exceptions

InvalidArgument if the var is not in the tensor

Definition at line 673 of file tensor_tpl.h.

                                                                                    {
    const DiscreteVariable* var = nullptr;
 
    for (gum::Idx i = 0; i < this->nbrDim(); i++)
      if (this->variable(i).name() == varname) {
        var = &(this->variable(i));
        break;
      }
    if (var == nullptr)
      GUM_ERROR(InvalidArgument,
                "The variable '" << varname << "' to put first does not belong to the tensor")
    return this->putFirst(var);
  }

References GUM_ERROR, gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), putFirst(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

Here is the call graph for this function:

◆ random()

template<typename GUM_SCALAR>

const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::random ( ) const

generate a random Tensor with each parameter in [0,1]

Definition at line 745 of file tensor_tpl.h.

                                                                 {
    if (this->domainSize() == 0) return *this;
 
    std::vector< GUM_SCALAR > v;
    v.reserve(this->domainSize());
    for (Size i = 0; i < this->domainSize(); ++i) {
      auto r = (GUM_SCALAR)randomProba();
      v.push_back(r);
    }
    this->fillWith(v);
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::domainSize(), fillWith(), and gum::randomProba().

Here is the call graph for this function:

◆ randomCPT()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::randomCPT ( ) const

generate a random CPT in the Tensor

Definition at line 770 of file tensor_tpl.h.

                                                                           {
    if (this->domainSize() == 0) {
      this->fillWith((GUM_SCALAR)1.0);
    } else {
      gum::Instantiation I(*this);
      const auto&        v = this->variable(0);
      for (I.setFirstNotVar(v); !I.end(); I.incNotVar(v)) {
        const auto& distrib = gum::randomDistribution< GUM_SCALAR >(v.domainSize());
        for (I.setFirstVar(v); !I.end(); I.incVar(v)) {
          this->set(I, distrib[I.val(0)]);
        }
        I.unsetEnd();
      }
    }
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::domainSize(), gum::Instantiation::end(), fillWith(), gum::Instantiation::incNotVar(), gum::Instantiation::incVar(), gum::randomDistribution(), gum::MultiDimDecorator< GUM_SCALAR >::set(), gum::Instantiation::setFirstNotVar(), gum::Instantiation::setFirstVar(), gum::Instantiation::unsetEnd(), gum::Instantiation::val(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

Here is the call graph for this function:

◆ randomDistribution()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::randomDistribution ( ) const

generate a random Distribution in the Tensor

Definition at line 759 of file tensor_tpl.h.

                                                                                    {
    if (this->domainSize() == 0) {
      this->fillWith((GUM_SCALAR)1.0);
    } else {
      this->fillWith(gum::randomDistribution< GUM_SCALAR >(this->domainSize()));
    }
 
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::domainSize(), fillWith(), and gum::randomDistribution().

Here is the call graph for this function:

◆ reduce()

template<typename GUM_SCALAR>

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

finalvirtualinherited

compute lfold for this container

Parameters

f	the function to apply
base	the initial value

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 348 of file multiDimDecorator_tpl.h.

                                                                     {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->empty()) {
      return base;
    } else {
      return content_->reduce(f, base);
    }
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and empty().

Referenced by gum::Tensor< GUM_SCALAR >::maxNonOne(), and gum::Tensor< GUM_SCALAR >::minNonZero().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ registerSlave()

template<typename GUM_SCALAR>

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

finalvirtualinherited

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.

Implements gum::MultiDimAdressable.

Definition at line 246 of file multiDimDecorator_tpl.h.

                                                                             {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->registerSlave(i);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and registerSlave().

Referenced by registerSlave().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reorganize() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::reorganize ( const std::vector< const DiscreteVariable * > & vars ) const

create a new Tensor with another order

Exceptions

InvalidArgument if not all and only the vars of the tensor are in vars

Definition at line 618 of file tensor_tpl.h.

                                                                                             {
    if (vars.size() != this->nbrDim())
      GUM_ERROR(InvalidArgument,
                "The argument contains " << vars.size() << " variables instead of "
                                         << this->nbrDim() << ".")
    for (const auto var: vars) {
      if (!this->contains(*var))
        GUM_ERROR(InvalidArgument, "A variable in the argument does not belong to the tensor.")
    }
 
    Tensor< GUM_SCALAR > p;
    p.beginMultipleChanges();
    for (const auto var: vars)
      p.add(*var);
    p.endMultipleChanges();
    p.copyFrom(*this, nullptr);   // copy *this in p using the same order
 
    return p;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::contains(), and GUM_ERROR.

Referenced by putFirst(), and reorganize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reorganize() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::reorganize ( const std::vector< std::string > & vars ) const

create a new Tensor with another order

Exceptions

InvalidArgument if not all and only the vars of the tensor are in vars

Definition at line 640 of file tensor_tpl.h.

                                                                               {
    std::vector< const DiscreteVariable* > res;
 
    gum::HashTable< std::string, const gum::DiscreteVariable* > namesToVars;
    for (gum::Idx i = 0; i < this->nbrDim(); i++)
      namesToVars.insert(this->variable(i).name(), &(this->variable(i)));
 
    for (const auto& name: vars) {
      if (!namesToVars.exists(name)) {
        GUM_ERROR(gum::InvalidArgument,
                  "'" << name << "' is a not a name of a variable in this tensor")
      }
      res.push_back(namesToVars[name]);
    }
    return reorganize(res);
  }

References gum::HashTable< Key, Val >::exists(), GUM_ERROR, gum::HashTable< Key, Val >::insert(), gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), and reorganize().

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::MultiDimDecorator< GUM_SCALAR >::replace_	(	const DiscreteVariable *	x,
		const DiscreteVariable *	y )

protectedvirtualinherited

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 405 of file multiDimDecorator_tpl.h.

                                                                                   {
    this->content()->replace(*x, *y);
  }

References content().

Referenced by newFactory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scale()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::scale ( GUM_SCALAR v ) const

multiply (each value of) *this by v

Definition at line 437 of file tensor_tpl.h.

                                                                                   {
    this->apply([v](GUM_SCALAR x) { return x * v; });
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::apply().

Referenced by noising(), operator*=(), and operator/=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Default implementation of MultiDimContainer::set().

Calls get_ as a r-value.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 169 of file multiDimDecorator_tpl.h.

                                                                                     {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->nbrDim() == 0) {
      empty_value_ = value;
    } else {
      static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->set(i, value);
    }
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, empty_value_, nbrDim(), and set().

Referenced by gum::Tensor< GUM_SCALAR >::evEq(), gum::Tensor< GUM_SCALAR >::evGt(), gum::Tensor< GUM_SCALAR >::evIn(), gum::Tensor< GUM_SCALAR >::evLt(), gum::Tensor< GUM_SCALAR >::fillWith(), gum::Tensor< GUM_SCALAR >::fillWith(), gum::Tensor< GUM_SCALAR >::normalizeAsCPT(), gum::Tensor< GUM_SCALAR >::randomCPT(), and set().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setChangeNotification()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Listen to an assignment of a value in a Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 211 of file multiDimDecorator_tpl.h.

                                                                                           {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->setChangeNotification(i);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and setChangeNotification().

Referenced by setChangeNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setDecNotification()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Listen to increment in each recorded Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 239 of file multiDimDecorator_tpl.h.

                                                                                        {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->setDecNotification(i);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and setDecNotification().

Referenced by setDecNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setFirstNotification()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Listen to setFirst in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 218 of file multiDimDecorator_tpl.h.

                                                                                          {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->setFirstNotification(i);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and setFirstNotification().

Referenced by setFirstNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setIncNotification()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Listen to increment in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 232 of file multiDimDecorator_tpl.h.

                                                                                        {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->setIncNotification(i);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and setIncNotification().

Referenced by setIncNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setLastNotification()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Listen to setLast in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 225 of file multiDimDecorator_tpl.h.

                                                                                         {
    static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->setLastNotification(i);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and setLastNotification().

Referenced by setLastNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sgn()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::sgn ( ) const

apply sgn(x)$ on every element of the container

fill the tensor with -1 for a GUM_SCALAR<0,1 if >0 and 0 if ==0

Definition at line 343 of file tensor_tpl.h.

                                                                     {
    this->apply([](GUM_SCALAR x) { return (GUM_SCALAR(0) < x) - (x < GUM_SCALAR(0)); });
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::apply().

Here is the call graph for this function:

◆ sq()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::sq ( ) const

apply $x^2$ on every element of the container

Definition at line 331 of file tensor_tpl.h.

                                                                    {
    this->apply([](GUM_SCALAR x) { return x * x; });
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::apply().

Here is the call graph for this function:

◆ sum()

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::Tensor< GUM_SCALAR >::sum ( ) const

sum of all elements in the Tensor

Definition at line 157 of file tensor_tpl.h.

                                                    {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return this->empty_value_;
    }
    return gum::projectSum(*this->content());
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, and gum::projectSum().

Referenced by gum::GibbsOperator< GUM_SCALAR >::_GibbsSample_(), isEvidence(), normalize(), sumIn(), and sumOut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sumIn()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::sumIn ( const gum::VariableSet & kept_vars ) const

Projection using sum as operation (and implementation-optimized operations).

Parameters

kept_vars is the set of vars to keep

Definition at line 544 of file tensor_tpl.h.

                                                                                               {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return Tensor< GUM_SCALAR >().fillWith(this->empty_value_);
    }
 
    // if kept_var is empty, create an empty tensor
    // TODO: remove this test when operations will be able to handle empty tensors
    if (kept_vars.empty()) { return Tensor< GUM_SCALAR >().fillWith(this->sum()); }
 
    return Tensor< GUM_SCALAR >(gum::projectSum(*this->content(), complementVars_(kept_vars)));
  }

References complementVars_(), gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::Set< Key >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, gum::projectSum(), and sum().

Here is the call graph for this function:

◆ sumOut()

template<typename GUM_SCALAR>

INLINE Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::sumOut ( const gum::VariableSet & del_vars ) const

Projection using sum as operation (and implementation-optimized operations).

Parameters

del_vars is the set of vars to eliminate

Definition at line 455 of file tensor_tpl.h.

                                                                                               {
    if (static_cast< MultiDimContainer< GUM_SCALAR >* >(this->content_)->empty()) {
      return Tensor< GUM_SCALAR >().fillWith(this->empty_value_);
    }
 
    // if we remove all the variables, create an empty tensor
    // TODO: remove this test when operations will be able to handle empty tensors
    if (this->variablesSequence().size() <= del_vars.size()) {
      bool equal = true;
      for (const auto var: this->variablesSequence()) {
        if (!del_vars.exists(var)) {
          equal = false;
          break;
        }
      }
      if (equal) { return Tensor< GUM_SCALAR >().fillWith(this->sum()); }
    }
 
    return Tensor< GUM_SCALAR >(gum::projectSum(*this->content(), del_vars));
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::MultiDimDecorator< GUM_SCALAR >::content_, gum::MultiDimDecorator< GUM_SCALAR >::empty(), gum::MultiDimDecorator< GUM_SCALAR >::empty_value_, gum::Set< Key >::exists(), gum::projectSum(), gum::Set< Key >::size(), sum(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

Here is the call graph for this function:

◆ swapContent_()

template<typename GUM_SCALAR>

INLINE void gum::MultiDimDecorator< GUM_SCALAR >::swapContent_ ( MultiDimImplementation< GUM_SCALAR > * aContent ) const

protectedinherited

protected method to swap the implementation behind the Tensor

Warning: unsafe method for slave Instantiations !

Definition at line 386 of file multiDimDecorator_tpl.h.

                                                            {
    if (aContent != nullptr) {
      // TODO : frees all slave instantiations
      // TODO : control the dimensions ?
      MultiDimImplementation< GUM_SCALAR >* tmp = content_;
      content_                                  = aContent;
      // registers all instantiations
      delete (tmp);
    }
  }

References content_.

Referenced by newFactory().

Here is the caller graph for this function:

◆ toString() [1/2]

template<typename GUM_SCALAR>

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

virtualinherited

Default implementation of MultiDimContainer::set().

Calls get_ as a r-value.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 400 of file multiDimDecorator_tpl.h.

                                                                                         {
    return content_->toString(i);
  }

References content_.

Referenced by newFactory().

Here is the caller graph for this function:

◆ toString() [2/2]

template<typename GUM_SCALAR>

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

nodiscardfinalvirtual

the function to be used to add two Tensors

Reimplemented from gum::MultiDimDecorator< GUM_SCALAR >.

Definition at line 999 of file tensor_tpl.h.

                                                 {
    auto              table = this->content();
    std::stringstream ss;
 
    if (table->nbrDim() == 0) {
      Instantiation I(this);
      ss << "[" << this->get(I) << "]";
      return ss.str();
    }
    const Size colwidth    = 6;
    const Size numberwidth = 9;
    const Size nbrLigMax   = 6;
 
    ss << std::left << std::fixed << std::endl;
    ss.precision(numberwidth - 5);
 
    const auto& var = table->variable(0);
 
    const Size        nbparents = table->nbrDim() - 1;
    const Size        nbcol     = var.domainSize();
    const std::string maskparent(colwidth, '-');
    const std::string masknumber(numberwidth, '-');
 
    if (nbparents > 0)
      ss << std::setw(nbparents * (colwidth + 1) - 1) << " "
         << "||";
    ss << "  " << std::setw(nbcol * (numberwidth + 1) - 3)
       << var.name().substr(0, nbcol * (numberwidth + 1) - 3) << "|";
    ss << std::endl;
 
    if (nbparents > 0) {
      for (Idx i = 1; i <= nbparents; i++)
        ss << std::setw(colwidth) << table->variable(i).name().substr(0, colwidth) << "|";
      ss << "|";
    }
    for (Idx i = 0; i < nbcol; i++)
      ss << std::setw(numberwidth) << var.label(i).substr(0, numberwidth) << "|";
    ss << std::endl;
 
 
    if (nbparents > 0) {
      for (Idx i = 1; i <= nbparents; i++)
        ss << maskparent << "|";
      ss << "|";
    }
    for (Idx i = 0; i < nbcol; i++)
      ss << masknumber << "|";
    ss << std::endl;
    Instantiation I(*table);
 
    const auto drawligne = [&]() {
      if (nbparents > 0) {
        for (Idx i = 1; i <= nbparents; i++)
          ss << std::setw(colwidth) << table->variable(i).label(I.val(i)).substr(0, colwidth)
             << "|";
        ss << "|";
      }
      for (I.setFirstVar(var); !I.end(); I.incVar(var))
        ss << " " << std::setw(numberwidth - 1) << table->get(I) << "|";
      I.setFirstVar(var);
      ss << std::endl;
    };
 
    if (const Size nbrLig = table->domainSize() / var.domainSize(); nbrLig < nbrLigMax * 2 + 1) {
      for (I.setFirst(); !I.end(); I.incNotVar(var))
        drawligne();
    } else {
      Size cpt = 0;
      for (I.setFirst(); !I.end(); I.incNotVar(var)) {
        cpt++;
        if (cpt > nbrLigMax) break;
        drawligne();
      }
      ss << "[..." << nbrLig - nbrLigMax * 2 << " more line(s) ...]" << std::endl;
      I.setLast();
      for (Idx revi = 1; revi < nbrLigMax; revi++)
        I.decNotVar(var);
      for (I.setFirstVar(var); !I.end(); I.incNotVar(var)) {
        drawligne();
      }
    }
 
    return ss.str();
  }

References gum::MultiDimDecorator< GUM_SCALAR >::content(), gum::Instantiation::decNotVar(), gum::Instantiation::end(), gum::MultiDimDecorator< GUM_SCALAR >::get(), gum::Instantiation::incNotVar(), gum::Instantiation::incVar(), gum::Instantiation::setFirst(), gum::Instantiation::setFirstVar(), gum::Instantiation::setLast(), and gum::Instantiation::val().

Here is the call graph for this function:

◆ translate()

template<typename GUM_SCALAR>

INLINE const Tensor< GUM_SCALAR > & gum::Tensor< GUM_SCALAR >::translate ( GUM_SCALAR v ) const

add v to (each value of) *this

Definition at line 443 of file tensor_tpl.h.

                                                                                       {
    this->apply([v](GUM_SCALAR x) { return x + v; });
    return *this;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::apply().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uniformTensor()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::Tensor< GUM_SCALAR >::uniformTensor ( const DiscreteVariable & var )

static

Definition at line 1178 of file tensor_tpl.h.

                                                                                      {
    Tensor< GUM_SCALAR > pot;
 
    pot.beginMultipleChanges();
    pot << var;
    pot.endMultipleChanges(GUM_SCALAR(1.0));
 
    pot.normalize();
 
    return pot;
  }

◆ unregisterSlave()

template<typename GUM_SCALAR>

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

finalvirtualinherited

Unregister i as a slave of this MultiDimAdressable.

Parameters

i	The Instantiation to free.

Returns: Returns true, whatever happens.

Implements gum::MultiDimAdressable.

Definition at line 288 of file multiDimDecorator_tpl.h.

                                                                               {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->unregisterSlave(i);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and unregisterSlave().

Referenced by unregisterSlave().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ variable() [1/2]

template<typename GUM_SCALAR>

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

finalvirtualinherited

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 267 of file multiDimDecorator_tpl.h.

                                                                           {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->variable(name);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and variable().

Here is the call graph for this function:

◆ variable() [2/2]

template<typename GUM_SCALAR>

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

finalvirtualinherited

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 261 of file multiDimDecorator_tpl.h.

                                                                                      {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->variable(i);
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and variable().

Referenced by gum::Tensor< GUM_SCALAR >::draw(), erase(), gum::Tensor< GUM_SCALAR >::fillWith(), gum::Tensor< GUM_SCALAR >::normalizeAsCPT(), gum::Tensor< GUM_SCALAR >::operator&(), gum::Tensor< GUM_SCALAR >::operator|(), gum::Tensor< GUM_SCALAR >::putFirst(), gum::Tensor< GUM_SCALAR >::putFirst(), gum::Tensor< GUM_SCALAR >::randomCPT(), variable(), and variable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ variablesSequence()

template<typename GUM_SCALAR>

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

finalvirtualinherited

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 313 of file multiDimDecorator_tpl.h.

                                                                        {
    return static_cast< MultiDimContainer< GUM_SCALAR >* >(content_)->variablesSequence();
  }

References gum::MultiDimContainer< GUM_SCALAR >::MultiDimContainer(), content_, and variablesSequence().

Referenced by gum::Tensor< GUM_SCALAR >::complementVars_(), gum::learning::DAG2BNLearner::createBNwithEM(), gum::Tensor< GUM_SCALAR >::fillWith(), gum::Tensor< GUM_SCALAR >::KL(), gum::Tensor< GUM_SCALAR >::maxOut(), gum::Tensor< GUM_SCALAR >::minOut(), gum::Tensor< GUM_SCALAR >::prodOut(), gum::Tensor< GUM_SCALAR >::sumOut(), and variablesSequence().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ content_

template<typename GUM_SCALAR>

MultiDimImplementation< GUM_SCALAR >* gum::MultiDimDecorator< GUM_SCALAR >::content_

mutableprotectedinherited

The true container.

Definition at line 271 of file multiDimDecorator.h.

◆ empty_value_

template<typename GUM_SCALAR>

GUM_SCALAR gum::MultiDimDecorator< GUM_SCALAR >::empty_value_

mutableprotectedinherited

value of the MultiDimDecorator if no dimension.

Definition at line 285 of file multiDimDecorator.h.

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

agrum/base/multidim/tensor.h
agrum/base/multidim/tensor_tpl.h

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Tensor() [1/6]

◆ Tensor() [2/6]

◆ Tensor() [3/6]

◆ Tensor() [4/6]

◆ Tensor() [5/6]

◆ Tensor() [6/6]

◆ ~Tensor()

Member Function Documentation

◆ abs()

◆ add()

◆ apply()

◆ argmax()

◆ argmin()

◆ beginMultipleChanges()

◆ changeNotification()

◆ complementVars_()

◆ contains()

◆ content() [1/2]

◆ content() [2/2]

◆ copy()

◆ copyFrom() [1/2]

◆ copyFrom() [2/2]

◆ deterministicTensor() [1/2]

◆ deterministicTensor() [2/2]

◆ domainSize()

◆ draw()

◆ empty()

◆ endMultipleChanges() [1/2]

◆ endMultipleChanges() [2/2]

◆ entropy()

◆ erase() [1/2]

◆ erase() [2/2]

◆ evEq()

◆ evGt()

◆ evIn()

◆ evLt()

◆ expectedValue()

Warnings

◆ extract()

◆ extractFrom()

◆ fill()

◆ fillWith() [1/4]

◆ fillWith() [2/4]

◆ fillWith() [3/4]

◆ fillWith() [4/4]

◆ findAll()

◆ get()

◆ get_()

◆ getMasterRef() [1/2]

◆ getMasterRef() [2/2]

◆ inverse()

◆ isEvidence()

◆ isNonZeroMap()

◆ KL()

◆ log2()

◆ max()

◆ maxIn()

◆ maxNonOne()

◆ maxOut()

◆ memoryFootprint()

◆ min()

◆ minIn()

◆ minNonZero()

◆ minOut()

◆ nbrDim()

◆ new_abs()

◆ new_log2()

◆ new_sgn()

◆ new_sq()

◆ newFactory()

◆ noising()

◆ normalize()

◆ normalizeAsCPT()

◆ notifyChange()