Collaboration diagram for Operators on multidimensional tables:

Classes
struct	gum::CompleteProjections4MultiDimInitialize< GUM_SCALAR >
	a class used to register complete projections over non-pointers types More...
struct	gum::CompleteProjections4MultiDimInitialize< GUM_SCALAR * >
	a class used to register complete projections over pointers types More...
struct	gum::Operators4MultiDimInitialize< GUM_SCALAR >
	a class used to register operators over non-pointers types More...
struct	gum::Operators4MultiDimInitialize< GUM_SCALAR * >
	a class used to register operators over pointers types More...
class	gum::CompleteProjectionRegister4MultiDim< GUM_SCALAR >
	A container for registering complete projection functions on multiDimImplementations, i.e., functions projecting tables over all their variables. More...
class	gum::MultiDimCombination< TABLE >
	A generic interface to combine efficiently several MultiDim tables. More...
class	gum::MultiDimCombinationDefault< TABLE >
	A class to combine efficiently several MultiDim tables. More...
class	gum::MultiDimCombineAndProject< TABLE >
	A generic interface to combine and project efficiently MultiDim tables. More...
class	gum::MultiDimCombineAndProjectDefault< TABLE >
	An efficient class for combining and projecting MultiDim tables. More...
class	gum::MultiDimCompleteProjection< GUM_SCALAR, TABLE >
	A generic class to project efficiently a MultiDim table over all of its variables. More...
class	gum::MultiDimProjection< TABLE >
	A generic class to project efficiently a MultiDim table over a subset of its variables. More...
class	gum::OperatorRegister4MultiDim< GUM_SCALAR >
	A container for registering binary functions on multiDimImplementations. More...
class	gum::ProjectionRegister4MultiDim< GUM_SCALAR >
	A container for registering projection functions on multiDimImplementations, i.e., functions projecting tables over a subset of their variables. More...

Functions
template<typename GUM_SCALAR>
void	gum::registerCompleteProjection (const std::string &projection_name, const std::string &type_multidim, typename CompleteProjectionRegister4MultiDim< GUM_SCALAR >::CompleteProjectionPtr function)
	A function to more easily register new projection functions in MultiDims.
template<typename GUM_SCALAR>
void	gum::completeProjections4MultiDimInit ()
	the function used to register all the complete projection operators on multidimImplementations over non-pointers types.
template<typename GUM_SCALAR>
void	gum::pointerCompleteProjections4MultiDimInit ()
	The function used to register all the complete projections on multidimImplementations over pointers types.
template<typename GUM_SCALAR>
void	gum::operators4MultiDimInit ()
	the function used to register all the operators on multidimImplementations over non-pointers types.
template<typename GUM_SCALAR>
void	gum::pointerOperators4MultiDimInit ()
	the function used to register all the operators on multidimImplementations over pointers types.

Project Max Operators
template<typename GUM_SCALAR>
GUM_SCALAR	gum::projectMaxMultiDimArray (const MultiDimArray< GUM_SCALAR > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Max operator.
template<typename GUM_SCALAR>
GUM_SCALAR	gum::projectMaxMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Max operator.
template<typename GUM_SCALAR>
GUM_SCALAR *	gum::projectMaxMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Max operator.
template<typename GUM_SCALAR>
GUM_SCALAR *	gum::projectMaxMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Max operator.

Project Min Operators
template<typename GUM_SCALAR>
GUM_SCALAR	gum::projectMinMultiDimArray (const MultiDimArray< GUM_SCALAR > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Min operator.
template<typename GUM_SCALAR>
GUM_SCALAR	gum::projectMinMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Min operator.
template<typename GUM_SCALAR>
GUM_SCALAR *	gum::projectMinMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Min operator.
template<typename GUM_SCALAR>
GUM_SCALAR *	gum::projectMinMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Min operator.

Project Sum Operators
template<typename GUM_SCALAR>
GUM_SCALAR	gum::projectSumMultiDimArray (const MultiDimArray< GUM_SCALAR > table, Instantiation instantiation=0)
	a specialized function for projecting a multiDimArray using a Sum operator
template<typename GUM_SCALAR>
GUM_SCALAR	gum::projectSumMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, Instantiation instantiation=0)
	a specialized function for projecting a multiDimArray using a Sum operator
template<typename GUM_SCALAR>
GUM_SCALAR *	gum::projectSumMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, Instantiation instantiation=0)
	a specialized function for projecting a multiDimArray using a Sum operator
template<typename GUM_SCALAR>
GUM_SCALAR *	gum::projectSumMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, Instantiation instantiation=0)
	a specialized function for projecting a multiDimArray using a Sum operator

Project Multiply Operators
template<typename GUM_SCALAR>
GUM_SCALAR	gum::projectProductMultiDimArray (const MultiDimArray< GUM_SCALAR > table, Instantiation instantiation=0)
	a function for projecting a multiDimArray using a Product operator
template<typename GUM_SCALAR>
GUM_SCALAR	gum::projectProductMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, Instantiation instantiation=0)
	a function for projecting a multiDimArray using a Product operator
template<typename GUM_SCALAR>
GUM_SCALAR *	gum::projectProductMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, Instantiation instantiation=0)
	a function for projecting a multiDimArray using a Product operator
template<typename GUM_SCALAR>
GUM_SCALAR *	gum::projectProductMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, Instantiation instantiation=0)
	a function for projecting a multiDimArray using a Product operator

Add MultiDims
template<typename T>
MultiDimArray< T > *	gum::add2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for summing two multiDimArrays
template<typename T>
MultiDimImplementation< T > *	gum::add2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for summing two multiDimArrays
template<typename T>
MultiDimArray< T * > *	gum::add2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for summing two multiDimArrays
template<typename T>
MultiDimImplementation< T * > *	gum::add2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for summing two multiDimArrays
template<typename T>
MultiDimFunctionGraph< T > *	gum::add2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for summing two multiDimArrays
template<typename T>
MultiDimImplementation< T > *	gum::add2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for summing two multiDimArrays

Substract MultiDims
template<typename T>
MultiDimArray< T > *	gum::subtract2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for subtracting two multiDimArrays
template<typename T>
MultiDimImplementation< T > *	gum::subtract2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for subtracting two multiDimArrays
template<typename T>
MultiDimArray< T * > *	gum::subtract2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for subtracting two multiDimArrays
template<typename T>
MultiDimImplementation< T * > *	gum::subtract2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for subtracting two multiDimArrays
template<typename T>
MultiDimFunctionGraph< T > *	gum::subtract2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for subtracting two multiDimArrays
template<typename T>
MultiDimImplementation< T > *	gum::subtract2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for subtracting two multiDimArrays

Multiply MultiDims
template<typename T>
MultiDimArray< T > *	gum::multiply2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for multiplying two multiDimArrays
template<typename T>
MultiDimImplementation< T > *	gum::multiply2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for multiplying two multiDimArrays
template<typename T>
MultiDimArray< T * > *	gum::multiply2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for multiplying two multiDimArrays
template<typename T>
MultiDimImplementation< T * > *	gum::multiply2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for multiplying two multiDimArrays
template<typename T>
MultiDimFunctionGraph< T > *	gum::multiply2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for multiplying two multiDimArrays
template<typename T>
MultiDimImplementation< T > *	gum::multiply2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for multiplying two multiDimArrays

Divide MultiDims
template<typename T>
MultiDimArray< T > *	gum::divide2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for dividing two multiDimArrays
template<typename T>
MultiDimImplementation< T > *	gum::divide2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for dividing two multiDimArrays
template<typename T>
MultiDimArray< T * > *	gum::divide2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for dividing two multiDimArrays
template<typename T>
MultiDimImplementation< T * > *	gum::divide2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for dividing two multiDimArrays
template<typename T>
MultiDimFunctionGraph< T > *	gum::divide2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for dividing two multiDimArrays
template<typename T>
MultiDimImplementation< T > *	gum::divide2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for dividing two multiDimArrays

Maximise MultiDims
template<typename T>
MultiDimFunctionGraph< T > *	gum::maximise2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for compare value from two multiDimFunctionGraphs and gets the maximal
template<typename T>
MultiDimImplementation< T > *	gum::maximise2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for compare value from two multiDimFunctionGraphs and gets the maximal

Operators over MultiDim
template<typename T>
MultiDimImplementation< T > *	gum::operator+ (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to add two MultiDimImplementations.
template<typename T>
MultiDimImplementation< T > *	gum::operator- (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to subtract two MultiDimImplementations.
template<typename T>
MultiDimImplementation< T > *	gum::operator* (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to multiply two MultiDimImplementations.
template<typename T>
MultiDimImplementation< T > *	gum::operator/ (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to divide two MultiDimImplementations.

Project Max for MultiDim
template<typename GUM_SCALAR>
MultiDimArray< GUM_SCALAR > *	gum::projectMaxMultiDimArray (const MultiDimArray< GUM_SCALAR > *table, const gum::VariableSet &del_vars)
	a specialized function for projecting a multiDimArray using a Max operator
template<typename GUM_SCALAR>
MultiDimImplementation< GUM_SCALAR > *	gum::projectMaxMultiDimArray (const MultiDimImplementation< GUM_SCALAR > *table, const gum::VariableSet &del_vars)
	a specialized function for projecting a multiDimArray using a Max operator
template<typename GUM_SCALAR>
MultiDimArray< GUM_SCALAR * > *	gum::projectMaxMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > *table, const gum::VariableSet &del_vars)
	a specialized function for projecting a multiDimArray using a Max operator
template<typename GUM_SCALAR>
MultiDimImplementation< GUM_SCALAR * > *	gum::projectMaxMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > *table, const gum::VariableSet &del_vars)
	a specialized function for projecting a multiDimArray using a Max operator

Detailed Description

Function Documentation

◆ add2MultiDimArrays() [1/2]

template<typename T>

MultiDimArray< T > * gum::add2MultiDimArrays	(	const MultiDimArray< T > *	t1,
		const MultiDimArray< T > *	t2 )

a specialized function for summing two multiDimArrays

The function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E.

Returns: function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

◆ add2MultiDimArrays() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::add2MultiDimArrays	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for summing two multiDimArrays

The function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E.

Returns: function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

◆ add2MultiDimArrays4Pointers() [1/2]

template<typename T>

MultiDimArray< T * > * gum::add2MultiDimArrays4Pointers	(	const MultiDimArray< T * > *	t1,
		const MultiDimArray< T * > *	t2 )

a specialized function for summing two multiDimArrays

The function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E.

Returns: function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

◆ add2MultiDimArrays4Pointers() [2/2]

template<typename T>

MultiDimImplementation< T * > * gum::add2MultiDimArrays4Pointers	(	const MultiDimImplementation< T * > *	t1,
		const MultiDimImplementation< T * > *	t2 )

a specialized function for summing two multiDimArrays

The function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E.

Returns: function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

◆ add2MultiDimFunctionGraphs() [1/2]

template<typename T>

MultiDimFunctionGraph< T > * gum::add2MultiDimFunctionGraphs	(	const MultiDimFunctionGraph< T > *	t1,
		const MultiDimFunctionGraph< T > *	t2 )

a specialized function for summing two multiDimArrays

The function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E.

Returns: function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

Referenced by gum::MDDOperatorStrategy< GUM_SCALAR >::add(), and gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration().

Here is the caller graph for this function:

◆ add2MultiDimFunctionGraphs() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::add2MultiDimFunctionGraphs	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for summing two multiDimArrays

The function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E.

Returns: function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

◆ completeProjections4MultiDimInit()

template<typename GUM_SCALAR>

void gum::completeProjections4MultiDimInit ( )

the function used to register all the complete projection operators on multidimImplementations over non-pointers types.

Referenced by gum::CompleteProjections4MultiDimInitialize< GUM_SCALAR >::init().

Here is the caller graph for this function:

◆ divide2MultiDimArrays() [1/2]

template<typename T>

MultiDimArray< T > * gum::divide2MultiDimArrays	(	const MultiDimArray< T > *	t1,
		const MultiDimArray< T > *	t2 )

a specialized function for dividing two multiDimArrays

The function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E.

Returns: function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

◆ divide2MultiDimArrays() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::divide2MultiDimArrays	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for dividing two multiDimArrays

The function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E.

Returns: function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

◆ divide2MultiDimArrays4Pointers() [1/2]

template<typename T>

MultiDimArray< T * > * gum::divide2MultiDimArrays4Pointers	(	const MultiDimArray< T * > *	t1,
		const MultiDimArray< T * > *	t2 )

a specialized function for dividing two multiDimArrays

The function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E.

Returns: function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

◆ divide2MultiDimArrays4Pointers() [2/2]

template<typename T>

MultiDimImplementation< T * > * gum::divide2MultiDimArrays4Pointers	(	const MultiDimImplementation< T * > *	t1,
		const MultiDimImplementation< T * > *	t2 )

a specialized function for dividing two multiDimArrays

The function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E.

Returns: function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

◆ divide2MultiDimFunctionGraphs() [1/2]

template<typename T>

MultiDimFunctionGraph< T > * gum::divide2MultiDimFunctionGraphs	(	const MultiDimFunctionGraph< T > *	t1,
		const MultiDimFunctionGraph< T > *	t2 )

a specialized function for dividing two multiDimArrays

The function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E.

Returns: function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

Referenced by gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration().

Here is the caller graph for this function:

◆ divide2MultiDimFunctionGraphs() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::divide2MultiDimFunctionGraphs	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for dividing two multiDimArrays

The function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E.

Returns: function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

◆ maximise2MultiDimFunctionGraphs() [1/2]

template<typename T>

MultiDimFunctionGraph< T > * gum::maximise2MultiDimFunctionGraphs	(	const MultiDimFunctionGraph< T > *	t1,
		const MultiDimFunctionGraph< T > *	t2 )

a specialized function for compare value from two multiDimFunctionGraphs and gets the maximal

The function produces a tensorial comparison between t1 and t2, that is, if t1 and t2 are multiDimFunctionGraphs over variables A,B,C,D and D,B,E respectively, function maximise2MultiDimFunctionGraphs will return a multiDimFunctionGraph T defined as T[A,B,C,D,E] = max( t1[A,B,C,D], t2[D,B,E] ) for all A,B,C,D,E.

Returns: function maximise2MultiDimFunctionGraphs allocates on the heap the new T multiDimFunctionGraph and returns it

◆ maximise2MultiDimFunctionGraphs() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::maximise2MultiDimFunctionGraphs	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for compare value from two multiDimFunctionGraphs and gets the maximal

The function produces a tensorial comparison between t1 and t2, that is, if t1 and t2 are multiDimFunctionGraphs over variables A,B,C,D and D,B,E respectively, function maximise2MultiDimFunctionGraphs will return a multiDimFunctionGraph T defined as T[A,B,C,D,E] = max( t1[A,B,C,D], t2[D,B,E] ) for all A,B,C,D,E.

Returns: function maximise2MultiDimFunctionGraphs allocates on the heap the new T multiDimFunctionGraph and returns it

◆ multiply2MultiDimArrays() [1/2]

template<typename T>

MultiDimArray< T > * gum::multiply2MultiDimArrays	(	const MultiDimArray< T > *	t1,
		const MultiDimArray< T > *	t2 )

a specialized function for multiplying two multiDimArrays

The function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E.

Returns: function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

◆ multiply2MultiDimArrays() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::multiply2MultiDimArrays	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for multiplying two multiDimArrays

The function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E.

Returns: function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

◆ multiply2MultiDimArrays4Pointers() [1/2]

template<typename T>

MultiDimArray< T * > * gum::multiply2MultiDimArrays4Pointers	(	const MultiDimArray< T * > *	t1,
		const MultiDimArray< T * > *	t2 )

a specialized function for multiplying two multiDimArrays

The function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E.

Returns: function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

◆ multiply2MultiDimArrays4Pointers() [2/2]

template<typename T>

MultiDimImplementation< T * > * gum::multiply2MultiDimArrays4Pointers	(	const MultiDimImplementation< T * > *	t1,
		const MultiDimImplementation< T * > *	t2 )

a specialized function for multiplying two multiDimArrays

The function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E.

Returns: function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

◆ multiply2MultiDimFunctionGraphs() [1/2]

template<typename T>

MultiDimFunctionGraph< T > * gum::multiply2MultiDimFunctionGraphs	(	const MultiDimFunctionGraph< T > *	t1,
		const MultiDimFunctionGraph< T > *	t2 )

a specialized function for multiplying two multiDimArrays

The function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E.

Returns: function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

Referenced by gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), and gum::MDDOperatorStrategy< GUM_SCALAR >::multiply().

Here is the caller graph for this function:

◆ multiply2MultiDimFunctionGraphs() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::multiply2MultiDimFunctionGraphs	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for multiplying two multiDimArrays

The function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E.

Returns: function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

◆ operator*()

template<typename T>

MultiDimImplementation< T > * gum::operator*	(	const MultiDimImplementation< T > &	,
		const MultiDimImplementation< T > &	)

The function to be used to multiply two MultiDimImplementations.

◆ operator+()

template<typename T>

MultiDimImplementation< T > * gum::operator+	(	const MultiDimImplementation< T > &	,
		const MultiDimImplementation< T > &	)

The function to be used to add two MultiDimImplementations.

◆ operator-()

template<typename T>

MultiDimImplementation< T > * gum::operator-	(	const MultiDimImplementation< T > &	,
		const MultiDimImplementation< T > &	)

The function to be used to subtract two MultiDimImplementations.

◆ operator/()

template<typename T>

MultiDimImplementation< T > * gum::operator/	(	const MultiDimImplementation< T > &	,
		const MultiDimImplementation< T > &	)

The function to be used to divide two MultiDimImplementations.

◆ operators4MultiDimInit()

template<typename GUM_SCALAR>

void gum::operators4MultiDimInit ( )

the function used to register all the operators on multidimImplementations over non-pointers types.

Referenced by gum::Operators4MultiDimInitialize< GUM_SCALAR >::init().

Here is the caller graph for this function:

◆ pointerCompleteProjections4MultiDimInit()

template<typename GUM_SCALAR>

void gum::pointerCompleteProjections4MultiDimInit ( )

The function used to register all the complete projections on multidimImplementations over pointers types.

Referenced by gum::CompleteProjections4MultiDimInitialize< GUM_SCALAR * >::init().

Here is the caller graph for this function:

◆ pointerOperators4MultiDimInit()

template<typename GUM_SCALAR>

void gum::pointerOperators4MultiDimInit ( )

the function used to register all the operators on multidimImplementations over pointers types.

Referenced by gum::Operators4MultiDimInitialize< GUM_SCALAR * >::init().

Here is the caller graph for this function:

◆ projectMaxMultiDimArray() [1/4]

template<typename GUM_SCALAR>

MultiDimArray< GUM_SCALAR > * gum::projectMaxMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		const gum::VariableSet &	del_vars )

a specialized function for projecting a multiDimArray using a Max operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Max_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMaxMultiDimArray() [2/4]

template<typename GUM_SCALAR>

GUM_SCALAR gum::projectMaxMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		Instantiation *	instantiation = 0 )

A specialized function for projecting a multiDimArray using a Max operator.

The function projects a table over all its variables and, thus, returns the max value stored in the table.

Parameters

table	a pointer on the multidim table to be projected
instantiation	if instantiation is different from 0, then the projection function stores in the instantation the values of the variables that led to the max (hence, the argmax).

Returns: the max value stored in the multiDimArray

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMaxMultiDimArray() [3/4]

template<typename GUM_SCALAR>

MultiDimImplementation< GUM_SCALAR > * gum::projectMaxMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const gum::VariableSet &	del_vars )

a specialized function for projecting a multiDimArray using a Max operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Max_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMaxMultiDimArray() [4/4]

template<typename GUM_SCALAR>

GUM_SCALAR gum::projectMaxMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		Instantiation *	instantiation = 0 )

A specialized function for projecting a multiDimArray using a Max operator.

The function projects a table over all its variables and, thus, returns the max value stored in the table.

Parameters

table	a pointer on the multidim table to be projected
instantiation	if instantiation is different from 0, then the projection function stores in the instantation the values of the variables that led to the max (hence, the argmax).

Returns: the max value stored in the multiDimArray

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMaxMultiDimArray4Pointers() [1/4]

template<typename GUM_SCALAR>

MultiDimArray< GUM_SCALAR * > * gum::projectMaxMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		const gum::VariableSet &	del_vars )

a specialized function for projecting a multiDimArray using a Max operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Max_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMaxMultiDimArray4Pointers() [2/4]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::projectMaxMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		Instantiation *	instantiation = 0 )

A specialized function for projecting a multiDimArray using a Max operator.

The function projects a table over all its variables and, thus, returns the max value stored in the table.

Parameters

table	a pointer on the multidim table to be projected
instantiation	if instantiation is different from 0, then the projection function stores in the instantation the values of the variables that led to the max (hence, the argmax).

Returns: the max value stored in the multiDimArray

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMaxMultiDimArray4Pointers() [3/4]

template<typename GUM_SCALAR>

MultiDimImplementation< GUM_SCALAR * > * gum::projectMaxMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		const gum::VariableSet &	del_vars )

a specialized function for projecting a multiDimArray using a Max operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Max_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMaxMultiDimArray4Pointers() [4/4]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::projectMaxMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		Instantiation *	instantiation = 0 )

A specialized function for projecting a multiDimArray using a Max operator.

The function projects a table over all its variables and, thus, returns the max value stored in the table.

Parameters

table	a pointer on the multidim table to be projected
instantiation	if instantiation is different from 0, then the projection function stores in the instantation the values of the variables that led to the max (hence, the argmax).

Returns: the max value stored in the multiDimArray

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimArray() [1/2]

template<typename GUM_SCALAR>

GUM_SCALAR gum::projectMinMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		Instantiation *	instantiation = 0 )

A specialized function for projecting a multiDimArray using a Min operator.

The function projects a table over all its variables and, thus, returns the min value stored in the table

Returns: the min value stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	if instantiation is different from 0, then the projection function stores in the instantation the values of the variables that led to the min (hence, the argmin).

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimArray() [2/2]

template<typename GUM_SCALAR>

GUM_SCALAR gum::projectMinMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		Instantiation *	instantiation = 0 )

A specialized function for projecting a multiDimArray using a Min operator.

The function projects a table over all its variables and, thus, returns the min value stored in the table

Returns: the min value stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	if instantiation is different from 0, then the projection function stores in the instantation the values of the variables that led to the min (hence, the argmin).

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimArray4Pointers() [1/2]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::projectMinMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		Instantiation *	instantiation = 0 )

A specialized function for projecting a multiDimArray using a Min operator.

The function projects a table over all its variables and, thus, returns the min value stored in the table

Returns: the min value stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	if instantiation is different from 0, then the projection function stores in the instantation the values of the variables that led to the min (hence, the argmin).

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimArray4Pointers() [2/2]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::projectMinMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		Instantiation *	instantiation = 0 )

A specialized function for projecting a multiDimArray using a Min operator.

The function projects a table over all its variables and, thus, returns the min value stored in the table

Returns: the min value stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	if instantiation is different from 0, then the projection function stores in the instantation the values of the variables that led to the min (hence, the argmin).

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimArray() [1/2]

template<typename GUM_SCALAR>

GUM_SCALAR gum::projectProductMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		Instantiation *	instantiation = 0 )

a function for projecting a multiDimArray using a Product operator

The function projects a table over all its variables and, thus, returns the product of the values stored in the table

Returns: the product of the values stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	It shall always be 0 else instantiation is updated with a meaningless value. In addition, setting instantiation to a value different than 0 will induce more computations and thus will slow down the projection.

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimArray() [2/2]

template<typename GUM_SCALAR>

GUM_SCALAR gum::projectProductMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		Instantiation *	instantiation = 0 )

a function for projecting a multiDimArray using a Product operator

The function projects a table over all its variables and, thus, returns the product of the values stored in the table

Returns: the product of the values stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	It shall always be 0 else instantiation is updated with a meaningless value. In addition, setting instantiation to a value different than 0 will induce more computations and thus will slow down the projection.

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimArray4Pointers() [1/2]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::projectProductMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		Instantiation *	instantiation = 0 )

a function for projecting a multiDimArray using a Product operator

The function projects a table over all its variables and, thus, returns the product of the values stored in the table

Returns: the product of the values stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	It shall always be 0 else instantiation is updated with a meaningless value. In addition, setting instantiation to a value different than 0 will induce more computations and thus will slow down the projection.

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimArray4Pointers() [2/2]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::projectProductMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		Instantiation *	instantiation = 0 )

a function for projecting a multiDimArray using a Product operator

The function projects a table over all its variables and, thus, returns the product of the values stored in the table

Returns: the product of the values stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	It shall always be 0 else instantiation is updated with a meaningless value. In addition, setting instantiation to a value different than 0 will induce more computations and thus will slow down the projection.

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimArray() [1/2]

template<typename GUM_SCALAR>

GUM_SCALAR gum::projectSumMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		Instantiation *	instantiation = 0 )

a specialized function for projecting a multiDimArray using a Sum operator

The function projects a table over all its variables and, thus, returns the sum of the values stored in the table

Returns: the sum of the values stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	It shall always be 0 else instantiation is updated with a meaningless value. In addition, setting instantiation to a value different than 0 will induce more computations and thus will slow down the projection.

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimArray() [2/2]

template<typename GUM_SCALAR>

GUM_SCALAR gum::projectSumMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		Instantiation *	instantiation = 0 )

a specialized function for projecting a multiDimArray using a Sum operator

The function projects a table over all its variables and, thus, returns the sum of the values stored in the table

Returns: the sum of the values stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	It shall always be 0 else instantiation is updated with a meaningless value. In addition, setting instantiation to a value different than 0 will induce more computations and thus will slow down the projection.

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimArray4Pointers() [1/2]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::projectSumMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		Instantiation *	instantiation = 0 )

a specialized function for projecting a multiDimArray using a Sum operator

The function projects a table over all its variables and, thus, returns the sum of the values stored in the table

Returns: the sum of the values stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	It shall always be 0 else instantiation is updated with a meaningless value. In addition, setting instantiation to a value different than 0 will induce more computations and thus will slow down the projection.

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimArray4Pointers() [2/2]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::projectSumMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		Instantiation *	instantiation = 0 )

a specialized function for projecting a multiDimArray using a Sum operator

The function projects a table over all its variables and, thus, returns the sum of the values stored in the table

Returns: the sum of the values stored in the multiDimArray

Parameters

table	a pointer on the multidim table to be projected
instantiation	It shall always be 0 else instantiation is updated with a meaningless value. In addition, setting instantiation to a value different than 0 will induce more computations and thus will slow down the projection.

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ registerCompleteProjection()

template<typename GUM_SCALAR>

void gum::registerCompleteProjection	(	const std::string &	projection_name,
		const std::string &	type_multidim,
		typename CompleteProjectionRegister4MultiDim< GUM_SCALAR >::CompleteProjectionPtr	function )

A function to more easily register new projection functions in MultiDims.

◆ subtract2MultiDimArrays() [1/2]

template<typename T>

MultiDimArray< T > * gum::subtract2MultiDimArrays	(	const MultiDimArray< T > *	t1,
		const MultiDimArray< T > *	t2 )

a specialized function for subtracting two multiDimArrays

The function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E.

Returns: function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

◆ subtract2MultiDimArrays() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::subtract2MultiDimArrays	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for subtracting two multiDimArrays

The function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E.

Returns: function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

◆ subtract2MultiDimArrays4Pointers() [1/2]

template<typename T>

MultiDimArray< T * > * gum::subtract2MultiDimArrays4Pointers	(	const MultiDimArray< T * > *	t1,
		const MultiDimArray< T * > *	t2 )

a specialized function for subtracting two multiDimArrays

The function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E.

Returns: function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

◆ subtract2MultiDimArrays4Pointers() [2/2]

template<typename T>

MultiDimImplementation< T * > * gum::subtract2MultiDimArrays4Pointers	(	const MultiDimImplementation< T * > *	t1,
		const MultiDimImplementation< T * > *	t2 )

a specialized function for subtracting two multiDimArrays

The function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E.

Returns: function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

◆ subtract2MultiDimFunctionGraphs() [1/2]

template<typename T>

MultiDimFunctionGraph< T > * gum::subtract2MultiDimFunctionGraphs	(	const MultiDimFunctionGraph< T > *	t1,
		const MultiDimFunctionGraph< T > *	t2 )

a specialized function for subtracting two multiDimArrays

The function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E.

Returns: function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

Referenced by gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), and gum::MDDOperatorStrategy< GUM_SCALAR >::subtract().

Here is the caller graph for this function:

◆ subtract2MultiDimFunctionGraphs() [2/2]

template<typename T>

MultiDimImplementation< T > * gum::subtract2MultiDimFunctionGraphs	(	const MultiDimImplementation< T > *	t1,
		const MultiDimImplementation< T > *	t2 )

a specialized function for subtracting two multiDimArrays

The function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E.

Returns: function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

Classes

Functions

Project Max Operators

Project Min Operators

Project Sum Operators

Project Multiply Operators

Add MultiDims

Substract MultiDims

Multiply MultiDims

Divide MultiDims

Maximise MultiDims

Operators over MultiDim

Project Max for MultiDim

Detailed Description

Function Documentation

◆ add2MultiDimArrays() [1/2]

◆ add2MultiDimArrays() [2/2]

◆ add2MultiDimArrays4Pointers() [1/2]

◆ add2MultiDimArrays4Pointers() [2/2]

◆ add2MultiDimFunctionGraphs() [1/2]

◆ add2MultiDimFunctionGraphs() [2/2]

◆ completeProjections4MultiDimInit()

◆ divide2MultiDimArrays() [1/2]

◆ divide2MultiDimArrays() [2/2]

◆ divide2MultiDimArrays4Pointers() [1/2]

◆ divide2MultiDimArrays4Pointers() [2/2]

◆ divide2MultiDimFunctionGraphs() [1/2]

◆ divide2MultiDimFunctionGraphs() [2/2]

◆ maximise2MultiDimFunctionGraphs() [1/2]

◆ maximise2MultiDimFunctionGraphs() [2/2]

◆ multiply2MultiDimArrays() [1/2]

◆ multiply2MultiDimArrays() [2/2]

◆ multiply2MultiDimArrays4Pointers() [1/2]

◆ multiply2MultiDimArrays4Pointers() [2/2]

◆ multiply2MultiDimFunctionGraphs() [1/2]

◆ multiply2MultiDimFunctionGraphs() [2/2]

◆ operator*()

◆ operator+()

◆ operator-()

◆ operator/()

◆ operators4MultiDimInit()

◆ pointerCompleteProjections4MultiDimInit()

◆ pointerOperators4MultiDimInit()

◆ projectMaxMultiDimArray() [1/4]

◆ projectMaxMultiDimArray() [2/4]

◆ projectMaxMultiDimArray() [3/4]

◆ projectMaxMultiDimArray() [4/4]

◆ projectMaxMultiDimArray4Pointers() [1/4]

◆ projectMaxMultiDimArray4Pointers() [2/4]

◆ projectMaxMultiDimArray4Pointers() [3/4]

◆ projectMaxMultiDimArray4Pointers() [4/4]

◆ projectMinMultiDimArray() [1/2]

◆ projectMinMultiDimArray() [2/2]

◆ projectMinMultiDimArray4Pointers() [1/2]

◆ projectMinMultiDimArray4Pointers() [2/2]

◆ projectProductMultiDimArray() [1/2]

◆ projectProductMultiDimArray() [2/2]

◆ projectProductMultiDimArray4Pointers() [1/2]

◆ projectProductMultiDimArray4Pointers() [2/2]

◆ projectSumMultiDimArray() [1/2]

◆ projectSumMultiDimArray() [2/2]

◆ projectSumMultiDimArray4Pointers() [1/2]

◆ projectSumMultiDimArray4Pointers() [2/2]

◆ registerCompleteProjection()

◆ subtract2MultiDimArrays() [1/2]

◆ subtract2MultiDimArrays() [2/2]

◆ subtract2MultiDimArrays4Pointers() [1/2]

◆ subtract2MultiDimArrays4Pointers() [2/2]

◆ subtract2MultiDimFunctionGraphs() [1/2]

◆ subtract2MultiDimFunctionGraphs() [2/2]