aGrUM 3.3.2
a C++ library for (probabilistic) graphical models
Operators on multidimensional tables
Collaboration diagram for Operators on multidimensional tables:

Classes

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

Functions

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

Project Max Operators

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

Project Min Operators

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

Project Sum Operators

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

Project Multiply Operators

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

Add MultiDims

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

Substract MultiDims

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

Multiply MultiDims

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

Divide MultiDims

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

Maximise MultiDims

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

Operators over MultiDim

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

Project Max for MultiDim

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

Detailed Description

Function Documentation

◆ add2MultiDimArrays() [1/2]

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

a specialized function for summing two multiDimArrays

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

Returns
function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

References add2MultiDimArrays().

Referenced by add2MultiDimArrays(), and add2MultiDimArrays().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ add2MultiDimArrays() [2/2]

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

a specialized function for summing two multiDimArrays

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

Returns
function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

References add2MultiDimArrays().

Here is the call graph for this function:

◆ add2MultiDimArrays4Pointers() [1/2]

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

a specialized function for summing two multiDimArrays

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

Returns
function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

References add2MultiDimArrays4Pointers().

Referenced by add2MultiDimArrays4Pointers(), and add2MultiDimArrays4Pointers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ add2MultiDimArrays4Pointers() [2/2]

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

a specialized function for summing two multiDimArrays

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

Returns
function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

References add2MultiDimArrays4Pointers().

Here is the call graph for this function:

◆ add2MultiDimFunctionGraphs() [1/2]

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

a specialized function for summing two multiDimArrays

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

Returns
function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

References add2MultiDimFunctionGraphs().

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ add2MultiDimFunctionGraphs() [2/2]

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

a specialized function for summing two multiDimArrays

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

Returns
function add2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator+ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your addition.

References add2MultiDimFunctionGraphs().

Here is the call graph for this function:

◆ completeProjections4MultiDimInit()

template<typename GUM_ELEMENT>
void gum::completeProjections4MultiDimInit ( )

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

References completeProjections4MultiDimInit().

Referenced by completeProjections4MultiDimInit().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ divide2MultiDimArrays() [1/2]

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

a specialized function for dividing two multiDimArrays

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

Returns
function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

References divide2MultiDimArrays().

Referenced by divide2MultiDimArrays(), and divide2MultiDimArrays().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ divide2MultiDimArrays() [2/2]

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

a specialized function for dividing two multiDimArrays

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

Returns
function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

References divide2MultiDimArrays().

Here is the call graph for this function:

◆ divide2MultiDimArrays4Pointers() [1/2]

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

a specialized function for dividing two multiDimArrays

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

Returns
function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

References divide2MultiDimArrays4Pointers().

Referenced by divide2MultiDimArrays4Pointers(), and divide2MultiDimArrays4Pointers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ divide2MultiDimArrays4Pointers() [2/2]

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

a specialized function for dividing two multiDimArrays

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

Returns
function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

References divide2MultiDimArrays4Pointers().

Here is the call graph for this function:

◆ divide2MultiDimFunctionGraphs() [1/2]

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

a specialized function for dividing two multiDimArrays

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

Returns
function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

References divide2MultiDimFunctionGraphs().

Referenced by divide2MultiDimFunctionGraphs(), divide2MultiDimFunctionGraphs(), and gum::FMDPFactory< GUM_ELEMENT >::endRewardDeclaration().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ divide2MultiDimFunctionGraphs() [2/2]

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

a specialized function for dividing two multiDimArrays

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

Returns
function divide2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/ on multiDimImplementations. This operator will take care to select this function if it is appropriate for your division.

References divide2MultiDimFunctionGraphs().

Here is the call graph for this function:

◆ maximise2MultiDimFunctionGraphs() [1/2]

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

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

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

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

References maximise2MultiDimFunctionGraphs().

Referenced by maximise2MultiDimFunctionGraphs(), and maximise2MultiDimFunctionGraphs().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ maximise2MultiDimFunctionGraphs() [2/2]

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

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

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

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

References maximise2MultiDimFunctionGraphs().

Here is the call graph for this function:

◆ multiply2MultiDimArrays() [1/2]

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

a specialized function for multiplying two multiDimArrays

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

Returns
function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

References multiply2MultiDimArrays().

Referenced by multiply2MultiDimArrays(), and multiply2MultiDimArrays().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ multiply2MultiDimArrays() [2/2]

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

a specialized function for multiplying two multiDimArrays

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

Returns
function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

References multiply2MultiDimArrays().

Here is the call graph for this function:

◆ multiply2MultiDimArrays4Pointers() [1/2]

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

a specialized function for multiplying two multiDimArrays

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

Returns
function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

References multiply2MultiDimArrays4Pointers().

Referenced by multiply2MultiDimArrays4Pointers(), and multiply2MultiDimArrays4Pointers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ multiply2MultiDimArrays4Pointers() [2/2]

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

a specialized function for multiplying two multiDimArrays

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

Returns
function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

References multiply2MultiDimArrays4Pointers().

Here is the call graph for this function:

◆ multiply2MultiDimFunctionGraphs() [1/2]

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

a specialized function for multiplying two multiDimArrays

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

Returns
function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

References multiply2MultiDimFunctionGraphs().

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ multiply2MultiDimFunctionGraphs() [2/2]

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

a specialized function for multiplying two multiDimArrays

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

Returns
function multiply2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator* on multiDimImplementations. This operator will take care to select this function if it is appropriate for your multiplication.

References multiply2MultiDimFunctionGraphs().

Here is the call graph for this function:

◆ operator*()

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

The function to be used to multiply two MultiDimImplementations.

References operator*().

Here is the call graph for this function:

◆ operator+()

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

The function to be used to add two MultiDimImplementations.

References operator+().

Here is the call graph for this function:

◆ operator-()

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

The function to be used to subtract two MultiDimImplementations.

References operator-().

Here is the call graph for this function:

◆ operator/()

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

The function to be used to divide two MultiDimImplementations.

References operator/().

Here is the call graph for this function:

◆ operators4MultiDimInit()

template<typename GUM_ELEMENT>
void gum::operators4MultiDimInit ( )

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

References operators4MultiDimInit().

Referenced by operators4MultiDimInit().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ pointerCompleteProjections4MultiDimInit()

template<typename GUM_ELEMENT>
void gum::pointerCompleteProjections4MultiDimInit ( )

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

References pointerCompleteProjections4MultiDimInit().

Referenced by pointerCompleteProjections4MultiDimInit().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ pointerOperators4MultiDimInit()

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

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

References pointerOperators4MultiDimInit().

Referenced by pointerOperators4MultiDimInit().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectMaxMultiDimArray() [1/4]

template<typename GUM_ELEMENT>
MultiDimArray< GUM_ELEMENT > * gum::projectMaxMultiDimArray ( const MultiDimArray< GUM_ELEMENT > * table,
const gum::VariableSet & del_vars )

a specialized function for projecting a multiDimArray using a Max operator

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

Returns
function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

References projectMaxMultiDimArray().

Here is the call graph for this function:

◆ projectMaxMultiDimArray() [2/4]

template<typename GUM_ELEMENT>
GUM_ELEMENT gum::projectMaxMultiDimArray ( const MultiDimArray< GUM_ELEMENT > * 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.

References projectMaxMultiDimArray().

Referenced by projectMaxMultiDimArray(), projectMaxMultiDimArray(), projectMaxMultiDimArray(), and projectMaxMultiDimArray().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectMaxMultiDimArray() [3/4]

template<typename GUM_ELEMENT>
MultiDimImplementation< GUM_ELEMENT > * gum::projectMaxMultiDimArray ( const MultiDimImplementation< GUM_ELEMENT > * table,
const gum::VariableSet & del_vars )

a specialized function for projecting a multiDimArray using a Max operator

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

Returns
function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

References projectMaxMultiDimArray().

Here is the call graph for this function:

◆ projectMaxMultiDimArray() [4/4]

template<typename GUM_ELEMENT>
GUM_ELEMENT gum::projectMaxMultiDimArray ( const MultiDimImplementation< GUM_ELEMENT > * 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.

References projectMaxMultiDimArray().

Here is the call graph for this function:

◆ projectMaxMultiDimArray4Pointers() [1/4]

template<typename GUM_ELEMENT>
MultiDimArray< GUM_ELEMENT * > * gum::projectMaxMultiDimArray4Pointers ( const MultiDimArray< GUM_ELEMENT * > * table,
const gum::VariableSet & del_vars )

a specialized function for projecting a multiDimArray using a Max operator

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

Returns
function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

References projectMaxMultiDimArray4Pointers().

Here is the call graph for this function:

◆ projectMaxMultiDimArray4Pointers() [2/4]

template<typename GUM_ELEMENT>
GUM_ELEMENT * gum::projectMaxMultiDimArray4Pointers ( const MultiDimArray< GUM_ELEMENT * > * 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.

References projectMaxMultiDimArray4Pointers().

Referenced by projectMaxMultiDimArray4Pointers(), projectMaxMultiDimArray4Pointers(), projectMaxMultiDimArray4Pointers(), and projectMaxMultiDimArray4Pointers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectMaxMultiDimArray4Pointers() [3/4]

template<typename GUM_ELEMENT>
MultiDimImplementation< GUM_ELEMENT * > * gum::projectMaxMultiDimArray4Pointers ( const MultiDimImplementation< GUM_ELEMENT * > * table,
const gum::VariableSet & del_vars )

a specialized function for projecting a multiDimArray using a Max operator

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

Returns
function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

References projectMaxMultiDimArray4Pointers().

Here is the call graph for this function:

◆ projectMaxMultiDimArray4Pointers() [4/4]

template<typename GUM_ELEMENT>
GUM_ELEMENT * gum::projectMaxMultiDimArray4Pointers ( const MultiDimImplementation< GUM_ELEMENT * > * 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.

References projectMaxMultiDimArray4Pointers().

Here is the call graph for this function:

◆ projectMinMultiDimArray() [1/2]

template<typename GUM_ELEMENT>
GUM_ELEMENT gum::projectMinMultiDimArray ( const MultiDimArray< GUM_ELEMENT > * 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.

References projectMinMultiDimArray().

Referenced by projectMinMultiDimArray(), projectMinMultiDimArray(), projectMinMultiDimArray(), and projectMinMultiDimArray().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectMinMultiDimArray() [2/2]

template<typename GUM_ELEMENT>
GUM_ELEMENT gum::projectMinMultiDimArray ( const MultiDimImplementation< GUM_ELEMENT > * 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.

References projectMinMultiDimArray().

Here is the call graph for this function:

◆ projectMinMultiDimArray4Pointers() [1/2]

template<typename GUM_ELEMENT>
GUM_ELEMENT * gum::projectMinMultiDimArray4Pointers ( const MultiDimArray< GUM_ELEMENT * > * 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.

References projectMinMultiDimArray4Pointers().

Referenced by projectMinMultiDimArray4Pointers(), projectMinMultiDimArray4Pointers(), projectMinMultiDimArray4Pointers(), and projectMinMultiDimArray4Pointers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectMinMultiDimArray4Pointers() [2/2]

template<typename GUM_ELEMENT>
GUM_ELEMENT * gum::projectMinMultiDimArray4Pointers ( const MultiDimImplementation< GUM_ELEMENT * > * 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.

References projectMinMultiDimArray4Pointers().

Here is the call graph for this function:

◆ projectProductMultiDimArray() [1/2]

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

a function for projecting a multiDimArray using a Product operator

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

Returns
the product of the values stored in the multiDimArray
Parameters
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.

References projectProductMultiDimArray().

Referenced by projectProductMultiDimArray(), projectProductMultiDimArray(), projectProductMultiDimArray(), and projectProductMultiDimArray().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectProductMultiDimArray() [2/2]

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

a function for projecting a multiDimArray using a Product operator

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

Returns
the product of the values stored in the multiDimArray
Parameters
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.

References projectProductMultiDimArray().

Here is the call graph for this function:

◆ projectProductMultiDimArray4Pointers() [1/2]

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

a function for projecting a multiDimArray using a Product operator

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

Returns
the product of the values stored in the multiDimArray
Parameters
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.

References projectProductMultiDimArray4Pointers().

Referenced by projectProductMultiDimArray4Pointers(), projectProductMultiDimArray4Pointers(), projectProductMultiDimArray4Pointers(), and projectProductMultiDimArray4Pointers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectProductMultiDimArray4Pointers() [2/2]

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

a function for projecting a multiDimArray using a Product operator

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

Returns
the product of the values stored in the multiDimArray
Parameters
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.

References projectProductMultiDimArray4Pointers().

Here is the call graph for this function:

◆ projectSumMultiDimArray() [1/2]

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

a specialized function for projecting a multiDimArray using a Sum operator

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

Returns
the sum of the values stored in the multiDimArray
Parameters
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.

References projectSumMultiDimArray().

Referenced by projectSumMultiDimArray(), projectSumMultiDimArray(), projectSumMultiDimArray(), and projectSumMultiDimArray().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectSumMultiDimArray() [2/2]

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

a specialized function for projecting a multiDimArray using a Sum operator

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

Returns
the sum of the values stored in the multiDimArray
Parameters
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.

References projectSumMultiDimArray().

Here is the call graph for this function:

◆ projectSumMultiDimArray4Pointers() [1/2]

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

a specialized function for projecting a multiDimArray using a Sum operator

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

Returns
the sum of the values stored in the multiDimArray
Parameters
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.

References projectSumMultiDimArray4Pointers().

Referenced by projectSumMultiDimArray4Pointers(), projectSumMultiDimArray4Pointers(), projectSumMultiDimArray4Pointers(), and projectSumMultiDimArray4Pointers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ projectSumMultiDimArray4Pointers() [2/2]

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

a specialized function for projecting a multiDimArray using a Sum operator

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

Returns
the sum of the values stored in the multiDimArray
Parameters
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.

References projectSumMultiDimArray4Pointers().

Here is the call graph for this function:

◆ registerCompleteProjection()

template<typename GUM_ELEMENT>
void gum::registerCompleteProjection ( std::string_view projection_name,
std::string_view type_multidim,
typename CompleteProjectionRegister4MultiDim< GUM_ELEMENT >::CompleteProjectionPtr function )

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

References registerCompleteProjection().

Referenced by registerCompleteProjection().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ subtract2MultiDimArrays() [1/2]

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

a specialized function for subtracting two multiDimArrays

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

Returns
function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

References subtract2MultiDimArrays().

Referenced by subtract2MultiDimArrays(), and subtract2MultiDimArrays().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ subtract2MultiDimArrays() [2/2]

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

a specialized function for subtracting two multiDimArrays

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

Returns
function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

References subtract2MultiDimArrays().

Here is the call graph for this function:

◆ subtract2MultiDimArrays4Pointers() [1/2]

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

a specialized function for subtracting two multiDimArrays

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

Returns
function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

References subtract2MultiDimArrays4Pointers().

Referenced by subtract2MultiDimArrays4Pointers(), and subtract2MultiDimArrays4Pointers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ subtract2MultiDimArrays4Pointers() [2/2]

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

a specialized function for subtracting two multiDimArrays

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

Returns
function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

References subtract2MultiDimArrays4Pointers().

Here is the call graph for this function:

◆ subtract2MultiDimFunctionGraphs() [1/2]

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

a specialized function for subtracting two multiDimArrays

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

Returns
function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

References subtract2MultiDimFunctionGraphs().

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ subtract2MultiDimFunctionGraphs() [2/2]

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

a specialized function for subtracting two multiDimArrays

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

Returns
function subtract2MultiDimArrays allocates on the heap the new T multiDimArray and returns it
Warning
In practice, do not use this function but rather operator- on multiDimImplementations. This operator will take care to select this function if it is appropriate for your subtraction.

References subtract2MultiDimFunctionGraphs().

Here is the call graph for this function: