Collaboration diagram for Operators on multidimensional tables:

Detailed Description

Classes
struct	gum::CompleteProjections4MultiDimInitialize< GUM_SCALAR >
	a class used to register complete projections over non-pointers typesThis class is of course completely redundant with function completeProjections4MultiDimInit. More...

struct	gum::CompleteProjections4MultiDimInitialize< GUM_SCALAR *>
	a class used to register complete projections over pointers typesThis class is of course completely redundant with function pointerCompleteProjections4MultiDimInit. More...

struct	gum::Operators4MultiDimInitialize< GUM_SCALAR >
	a class used to register operators over non-pointers typesThis class is of course completely redundant with function operators4MultiDimInit. More...

struct	gum::Operators4MultiDimInitialize< GUM_SCALAR *>
	a class used to register operators over pointers typesThis class is of course completely redundant with function pointerOperators4MultiDimInit. 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< GUM_SCALAR, TABLE >
	A generic interface to combine efficiently several MultiDim tables. More...

class	gum::MultiDimCombinationDefault< GUM_SCALAR, TABLE >
	A class to combine efficiently several MultiDim tablesMultiDimCombinationDefault is a class designed to combine efficiently several multidimensional objects, that is, to compute expressions like T1 op T2 op T3 op .... More...

class	gum::MultiDimCombineAndProject< GUM_SCALAR, TABLE >
	A generic interface to combine and project efficiently MultiDim tables. More...

class	gum::MultiDimCombineAndProjectDefault< GUM_SCALAR, 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< GUM_SCALAR, 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. More...

template<typename GUM_SCALAR >
void	gum::completeProjections4MultiDimInit ()
	the function used to register all the complete projection operators on multidimImplementations over non-pointers types. More...

template<typename GUM_SCALAR >
void	gum::pointerCompleteProjections4MultiDimInit ()
	The function used to register all the complete projections on multidimImplementations over pointers types. More...

template<typename GUM_SCALAR >
void	gum::operators4MultiDimInit ()
	the function used to register all the operators on multidimImplementations over non-pointers types. More...

template<typename GUM_SCALAR >
void	gum::pointerOperators4MultiDimInit ()
	the function used to register all the operators on multidimImplementations over pointers types. More...

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

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

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

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

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

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

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

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

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 operatorThe function projects a table over all its variables and, thus, returns the sum of the values stored in the table More...

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 operatorThe function projects a table over all its variables and, thus, returns the sum of the values stored in the table More...

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 operatorThe function projects a table over all its variables and, thus, returns the sum of the values stored in the table More...

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 operatorThe function projects a table over all its variables and, thus, returns the sum of the values stored in the table More...

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 operatorThe function projects a table over all its variables and, thus, returns the product of the values stored in the table More...

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 operatorThe function projects a table over all its variables and, thus, returns the product of the values stored in the table More...

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 operatorThe function projects a table over all its variables and, thus, returns the product of the values stored in the table More...

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 operatorThe function projects a table over all its variables and, thus, returns the product of the values stored in the table More...

Add MultiDims
template<typename T >
MultiDimArray< T > *	gum::add2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for summing two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T > *	gum::add2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for summing two multiDimArraysThe 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. More...

template<typename T >
MultiDimArray< T >	gum::add2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for summing two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T >	gum::add2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for summing two multiDimArraysThe 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. More...

template<typename T >
MultiDimFunctionGraph< T > *	gum::add2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for summing two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T > *	gum::add2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for summing two multiDimArraysThe 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. More...

Substract MultiDims
template<typename T >
MultiDimArray< T > *	gum::subtract2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for subtracting two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T > *	gum::subtract2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for subtracting two multiDimArraysThe 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. More...

template<typename T >
MultiDimArray< T >	gum::subtract2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for subtracting two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T >	gum::subtract2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for subtracting two multiDimArraysThe 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. More...

template<typename T >
MultiDimFunctionGraph< T > *	gum::subtract2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for subtracting two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T > *	gum::subtract2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for subtracting two multiDimArraysThe 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. More...

Multiply MultiDims
template<typename T >
MultiDimArray< T > *	gum::multiply2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for multiplying two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T > *	gum::multiply2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for multiplying two multiDimArraysThe 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. More...

template<typename T >
MultiDimArray< T >	gum::multiply2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for multiplying two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T >	gum::multiply2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for multiplying two multiDimArraysThe 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. More...

template<typename T >
MultiDimFunctionGraph< T > *	gum::multiply2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for multiplying two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T > *	gum::multiply2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for multiplying two multiDimArraysThe 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. More...

Divide MultiDims
template<typename T >
MultiDimArray< T > *	gum::divide2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for dividing two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T > *	gum::divide2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for dividing two multiDimArraysThe 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. More...

template<typename T >
MultiDimArray< T >	gum::divide2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for dividing two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T >	gum::divide2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for dividing two multiDimArraysThe 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. More...

template<typename T >
MultiDimFunctionGraph< T > *	gum::divide2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for dividing two multiDimArraysThe 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. More...

template<typename T >
MultiDimImplementation< T > *	gum::divide2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for dividing two multiDimArraysThe 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. More...

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 maximalThe 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. More...

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 maximalThe 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. More...

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

template<typename T >
MultiDimImplementation< T > *	gum::operator- (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to subtract two MultiDimImplementations. More...

template<typename T >
MultiDimImplementation< T > *	gum::operator* (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to multiply two MultiDimImplementations. More...

template<typename T >
MultiDimImplementation< T > *	gum::operator/ (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to divide two MultiDimImplementations. More...

Project Max for MultiDim
template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR > *	gum::projectMaxMultiDimArray (const MultiDimArray< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Max operatorThe function projects a table over the subset of its variables NOT IN the set of variables del_vars. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	gum::projectMaxMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Max operatorThe function projects a table over the subset of its variables NOT IN the set of variables del_vars. More...

template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR >	gum::projectMaxMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Max operatorThe function projects a table over the subset of its variables NOT IN the set of variables del_vars. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR >	gum::projectMaxMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Max operatorThe function projects a table over the subset of its variables NOT IN the set of variables del_vars. More...

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

template<typename T >

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

a specialized function for summing two multiDimArraysThe 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.

◆ divide2MultiDimArrays() [1/2]

template<typename T >

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

a specialized function for dividing two multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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() [2/2]

template<typename T >

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

a specialized function for dividing two multiDimArraysThe 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 maximalThe 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 maximalThe 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 multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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() [2/2]

template<typename T >

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

a specialized function for multiplying two multiDimArraysThe 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.

◆ pointerCompleteProjections4MultiDimInit()

template<typename GUM_SCALAR >

void gum::pointerCompleteProjections4MultiDimInit ( )

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

◆ pointerOperators4MultiDimInit()

template<typename GUM_SCALAR >

void gum::pointerOperators4MultiDimInit ( )

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

◆ projectMaxMultiDimArray() [1/4]

template<typename GUM_SCALAR >

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

a specialized function for projecting a multiDimArray using a Max operatorThe 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 Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a Max operatorThe 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 Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a Max operatorThe 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 Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a Max operatorThe 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 operatorThe 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 operatorThe 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 operatorThe 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 operatorThe 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 operatorThe 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 operatorThe 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 operatorThe 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 operatorThe 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 multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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 multiDimArraysThe 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() [2/2]

template<typename T >

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

a specialized function for subtracting two multiDimArraysThe 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.

Detailed Description

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

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]