aGrUM  0.13.2
Operators on multidimensional tables
+ 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

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

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

+ Here is the caller graph for this function:

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

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

+ Here is the caller graph for this function:

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

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

+ Here is the caller graph for this function:

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.
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 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 divide two MultiDimImplementations.

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::pointerCompleteProjections4MultiDimInit ( )

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

template<typename GUM_SCALAR >
void gum::pointerOperators4MultiDimInit ( )

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

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.
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
tablea pointer on the multidim table to be projected
instantiationif 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.
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.
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
tablea pointer on the multidim table to be projected
instantiationif 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.
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.
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
tablea pointer on the multidim table to be projected
instantiationif 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.
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.
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
tablea pointer on the multidim table to be projected
instantiationif 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.
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
tablea pointer on the multidim table to be projected
instantiationif 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.
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
tablea pointer on the multidim table to be projected
instantiationif 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.
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
tablea pointer on the multidim table to be projected
instantiationif 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.
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
tablea pointer on the multidim table to be projected
instantiationif 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.
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
tablea pointer on the multidim table to be projected
instantiationIt 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.
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
tablea pointer on the multidim table to be projected
instantiationIt 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.
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
tablea pointer on the multidim table to be projected
instantiationIt 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.
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
tablea pointer on the multidim table to be projected
instantiationIt 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.
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
tablea pointer on the multidim table to be projected
instantiationIt 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.
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
tablea pointer on the multidim table to be projected
instantiationIt 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.
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
tablea pointer on the multidim table to be projected
instantiationIt 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.
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
tablea pointer on the multidim table to be projected
instantiationIt 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.
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 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.
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.
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.
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.
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.

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

+ Here is the caller graph for this function:

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.