gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > Class Template Reference

a binary Combination operator class used for scheduling inferences More...

#include <agrum/graphicalModels/inference/scheduleBinaryCombination.h>

Inheritance diagram for gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >:

Collaboration diagram for gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >:

Public Member Functions
Constructors / Destructors
	ScheduleBinaryCombination (const ScheduleMultiDim< TABLE1 > &table1, const ScheduleMultiDim< TABLE2 > &table2, TABLE_RES(*combine)(const TABLE1 &, const TABLE2 &), const bool is_result_persistent=false)
	default constructor
	ScheduleBinaryCombination (const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &from)
	copy constructor
	ScheduleBinaryCombination (ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &&from)
	move constructor
ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > *	clone () const final
	virtual copy constructor
virtual	~ScheduleBinaryCombination ()
	destructor
Operators
ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &	operator= (const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &)
	copy operator
ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &	operator= (ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &&)
	move operator
bool	operator== (const ScheduleOperator &) const final
	operator ==
bool	operator!= (const ScheduleOperator &) const final
	operator !=
bool	operator== (const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &) const
	operator ==
bool	operator!= (const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &) const
	operator !=
Accessors/Modifiers
bool	hasSameArguments (const ScheduleOperator &) const final
	checks whether two ScheduleCombination have the same parameters (same variables and same content)
bool	hasSameArguments (const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &) const
	checks whether two ScheduleCombination have the same parameters (same variables and same content)
bool	hasSimilarArguments (const ScheduleOperator &) const final
	checks whether two ScheduleCombination have similar parameters (same variables)
bool	hasSimilarArguments (const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &) const
	checks whether two ScheduleCombination have similar parameters (same variables)
bool	isSameOperator (const ScheduleOperator &) const final
	checks whether two ScheduleOperator perform the same set of operations
bool	isSameOperator (const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &) const
	checks whether two ScheduleOperator perform the same set of operations
const ScheduleMultiDim< TABLE1 > &	arg1 () const
	returns the first argument of the combination
const ScheduleMultiDim< TABLE2 > &	arg2 () const
	returns the first argument of the combination
const Sequence< const IScheduleMultiDim * > &	args () const final
	returns the sequence of arguments passed to the operator
const ScheduleMultiDim< TABLE_RES > &	result () const
	returns the result of the combination
const Sequence< const IScheduleMultiDim * > &	results () const final
	returns the ScheduleMultidim resulting from the operator
void	updateArgs (const Sequence< const IScheduleMultiDim * > &new_args) final
	modifies the arguments of the operator
bool	isExecuted () const final
	indicates whether the operator has been executed
void	execute () final
	executes the operator
void	undo () final
	undo a previous execution, if any
double	nbOperations () const final
	returns an estimation of the number of elementary operations needed to perform the ScheduleOperator
std::pair< double, double >	memoryUsage () const final
	returns the memory consumption used during the execution of the operator
std::string	toString () const final
	displays the content of the operator
void	setCombinationFunction (TABLE_RES(*combine)(const TABLE1 &, const TABLE2 &))
	use a new combination function
Accessors/Modifiers
ScheduleOperatorType	type () const
	returns the type of the operator
bool	implyDeletion () const
	indicates whether the operator deletes some of its arguments
void	makeResultsPersistent (const bool is_persistent)
	makes the results of the operator persistent or not
bool	hasPersistentResults () const
	shows whether the operator has persistent results

Private Attributes
const ScheduleMultiDim< TABLE1 > *	_arg1_ {nullptr}
	the first argument of the combination
const ScheduleMultiDim< TABLE2 > *	_arg2_ {nullptr}
	the second argument of the combination
Sequence< const IScheduleMultiDim * >	_args_
	the sequence of arguments passed to the operator
ScheduleMultiDim< TABLE_RES > *	_result_ {nullptr}
	the result of the combination
Sequence< const IScheduleMultiDim * >	_results_
	the sequence of ScheduleMultidim output by the operator
TABLE_RES(*	_combine_ )(const TABLE1 &, const TABLE2 &)
	the function actually used to perform the combination
ScheduleOperatorType	_op_type_
	the name of the operator to perform
bool	_imply_deletion_
	indicates whether the operator will delete some of the ScheduleMultiDim passed as its arguments
bool	_result_persistent_
	is the result persistent

Detailed Description

template<typename TABLE1, typename TABLE2, typename TABLE_RES>
class gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >

a binary Combination operator class used for scheduling inferences

To be quite generic, the ScheduleBinaryCombination takes in argument the function that produces the result of the combination of the "real" tables contained within the ScheduleMultiDims to be combined. Note that executing a ScheduleBinaryCombination will always produce a freshly allocated table. The following code gives an example of the usage of ScheduleBinaryCombination:

// the combination function over "true" Tensors
Tensor< double > myadd(const gum::Tensor< double >& f1,
                          const gum::Tensor< double >& f2) {
  return f1 + f2;
}
 
// define the tensors to be combined and wrap them into ScheduleMultiDim
Tensor< double > pot1, pot2;
.......
ScheduleMultiDim< Tensor< double > > f1(pot1);
ScheduleMultiDim< Tensor< double > > f2(pot2);
 
// define the ScheduleBinaryCombination
ScheduleBinaryCombination< Tensor< double >,
                           Tensor< double >,
                           Tensor< double > > comb(f1, f2, myadd);
 
// before executing the combination, check whether we have sufficient
// memory and time to do it
const std::pair<double,double> memory = comb.memoryUsage();
const nb_operations = comb.nbOperations();
 
// execute the combination and get the result
comb.execute();
const ScheduleMultiDim< Tensor< double > >& result = comb.result();
const Tensor< double >& pot_result = result.multiDim();

Definition at line 102 of file scheduleBinaryCombination.h.

Constructor & Destructor Documentation

ScheduleBinaryCombination() [1/3]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::ScheduleBinaryCombination	(	const ScheduleMultiDim< TABLE1 > &	table1,
		const ScheduleMultiDim< TABLE2 > &	table2,
		TABLE_RES(*	combine )(const TABLE1 &, const TABLE2 &),
		const bool	is_result_persistent = false )

default constructor

Parameters

table1	the first ScheduleMultiDim to combine with the other table
table2	the second table involved in the combination
combine	a function taking two (real) tables in argument and returning the result of their combination
is_result_persistent	this boolean indicates whether the result of the binary combination is persistent, i.e., whether it should be kept in memory when the operator itself is deleted from memory.

Warning

tables 1 and 2 are stored only by reference within the ScheduleBinaryCombination.

Referenced by ScheduleBinaryCombination(), ScheduleBinaryCombination(), ~ScheduleBinaryCombination(), clone(), hasSameArguments(), hasSimilarArguments(), isSameOperator(), operator!=(), operator=(), operator=(), and operator==().

Here is the caller graph for this function:

ScheduleBinaryCombination() [2/3]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::ScheduleBinaryCombination

(

const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &

from

)

copy constructor

References ScheduleBinaryCombination().

Here is the call graph for this function:

ScheduleBinaryCombination() [3/3]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::ScheduleBinaryCombination

(

ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &&

from

)

move constructor

References ScheduleBinaryCombination().

Here is the call graph for this function:

~ScheduleBinaryCombination()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

virtual gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::~ScheduleBinaryCombination ( )

virtual

destructor

Warning

If the ScheduleOperator has created some output ScheduleMultiDim, upon destruction, it is removed from memory

References ScheduleBinaryCombination().

Here is the call graph for this function:

Member Function Documentation

arg1()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

const ScheduleMultiDim< TABLE1 > & gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::arg1

(

)

const

returns the first argument of the combination

References arg1().

Referenced by arg1().

Here is the call graph for this function:

Here is the caller graph for this function:

arg2()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

const ScheduleMultiDim< TABLE2 > & gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::arg2

(

)

const

returns the first argument of the combination

References arg2().

Referenced by arg2().

Here is the call graph for this function:

Here is the caller graph for this function:

args()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

const Sequence< const IScheduleMultiDim * > & gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::args ( ) const

finalvirtual

returns the sequence of arguments passed to the operator

Implements gum::ScheduleOperator.

References args().

Referenced by args().

Here is the call graph for this function:

Here is the caller graph for this function:

clone()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > * gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::clone ( ) const

finalvirtual

virtual copy constructor

Implements gum::ScheduleOperator.

References ScheduleBinaryCombination().

Here is the call graph for this function:

execute()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

void gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::execute ( )

finalvirtual

executes the operator

This method guarantees that the result of the combination is a stored into a newly allocated table

Implements gum::ScheduleOperator.

References execute().

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

hasPersistentResults()

bool gum::ScheduleOperator::hasPersistentResults ( ) const

inherited

shows whether the operator has persistent results

hasSameArguments() [1/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::hasSameArguments

(

const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &

)

const

checks whether two ScheduleCombination have the same parameters (same variables and same content)

Parameters having the same variables and the same content are essentially identical but they may have different Ids (so that they may not be ==).

References ScheduleBinaryCombination(), and hasSameArguments().

Here is the call graph for this function:

hasSameArguments() [2/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::hasSameArguments ( const ScheduleOperator & ) const

finalvirtual

checks whether two ScheduleCombination have the same parameters (same variables and same content)

Parameters having the same variables and the same content are essentially identical but they may have different Ids (so that they may not be ==).

Implements gum::ScheduleOperator.

References gum::ScheduleOperator::ScheduleOperator(), and hasSameArguments().

Referenced by hasSameArguments(), and hasSameArguments().

Here is the call graph for this function:

Here is the caller graph for this function:

hasSimilarArguments() [1/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::hasSimilarArguments

(

const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &

)

const

checks whether two ScheduleCombination have similar parameters (same variables)

References ScheduleBinaryCombination(), and hasSimilarArguments().

Here is the call graph for this function:

hasSimilarArguments() [2/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::hasSimilarArguments ( const ScheduleOperator & ) const

finalvirtual

checks whether two ScheduleCombination have similar parameters (same variables)

Implements gum::ScheduleOperator.

References gum::ScheduleOperator::ScheduleOperator(), and hasSimilarArguments().

Referenced by hasSimilarArguments(), and hasSimilarArguments().

Here is the call graph for this function:

Here is the caller graph for this function:

implyDeletion()

bool gum::ScheduleOperator::implyDeletion ( ) const

inherited

indicates whether the operator deletes some of its arguments

isExecuted()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::isExecuted ( ) const

finalvirtual

indicates whether the operator has been executed

Implements gum::ScheduleOperator.

References isExecuted().

Referenced by isExecuted().

Here is the call graph for this function:

Here is the caller graph for this function:

isSameOperator() [1/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::isSameOperator

(

const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &

)

const

checks whether two ScheduleOperator perform the same set of operations

References ScheduleBinaryCombination(), and isSameOperator().

Here is the call graph for this function:

isSameOperator() [2/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::isSameOperator ( const ScheduleOperator & ) const

finalvirtual

checks whether two ScheduleOperator perform the same set of operations

Reimplemented from gum::ScheduleOperator.

References gum::ScheduleOperator::ScheduleOperator(), and isSameOperator().

Referenced by isSameOperator(), and isSameOperator().

Here is the call graph for this function:

Here is the caller graph for this function:

makeResultsPersistent()

void gum::ScheduleOperator::makeResultsPersistent ( const bool is_persistent )

inherited

makes the results of the operator persistent or not

Unlike non-persistent results, a persistent one is not destroyed when the operator itself is destroyed

memoryUsage()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

std::pair< double, double > gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::memoryUsage ( ) const

finalvirtual

returns the memory consumption used during the execution of the operator

Actually, this function does not return a precise account of the memory used by the ScheduleOperator but a rough estimate based on the sizes of the tables involved in the operator.

Returns

a pair of memory consumption: the first one is the maximum amount of memory used during the execution of the operator and the second one is the amount of memory still used at the end of the function (the memory used by the resulting table)

Implements gum::ScheduleOperator.

References memoryUsage().

Referenced by memoryUsage().

Here is the call graph for this function:

Here is the caller graph for this function:

nbOperations()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

double gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::nbOperations ( ) const

finalvirtual

returns an estimation of the number of elementary operations needed to perform the ScheduleOperator

Implements gum::ScheduleOperator.

References nbOperations().

Referenced by nbOperations().

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=() [1/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::operator!=

(

const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &

)

const

operator !=

Two operators are different if and only if they either have different ScheduleMultiDim arguments or they perform different operations (e.g., one performs an addition and another one a subtraction). Different ScheduleMultiDim arguments means that the latter differ by their Ids.

References ScheduleBinaryCombination().

Here is the call graph for this function:

operator!=() [2/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::operator!= ( const ScheduleOperator & ) const

finalvirtual

operator !=

Two operators are different if and only if they either have different ScheduleMultiDim arguments or they perform different operations (e.g., one performs an addition and another one a subtraction). different ScheduleMultiDim arguments means that the latter differ by their Ids.

Reimplemented from gum::ScheduleOperator.

References gum::ScheduleOperator::ScheduleOperator().

Here is the call graph for this function:

operator=() [1/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > & gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::operator=

(

const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &

)

copy operator

References ScheduleBinaryCombination().

Here is the call graph for this function:

operator=() [2/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > & gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::operator=

(

ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &&

)

move operator

References ScheduleBinaryCombination().

Here is the call graph for this function:

operator==() [1/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::operator==

(

const ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > &

)

const

operator ==

Two operators are identical if and only if they have equal arguments and they perform the same operation (e.g., both perform additions). By Equal arguments, we mean that these ScheduleMultiDims have the same IDs

References ScheduleBinaryCombination().

Here is the call graph for this function:

operator==() [2/2]

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

bool gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::operator== ( const ScheduleOperator & ) const

finalvirtual

operator ==

Two operators are identical if and only if they have equal (==) arguments and they perform the same operations (e.g., both perform additions). By Equal arguments, we mean that these ScheduleMultiDims have the same IDs

Reimplemented from gum::ScheduleOperator.

References gum::ScheduleOperator::ScheduleOperator().

Here is the call graph for this function:

result()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

const ScheduleMultiDim< TABLE_RES > & gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::result

(

)

const

returns the result of the combination

Returns

the ScheduleMultiDim resulting from the combination. It is abstract if the combination has not been performed yet.

References result().

Referenced by result().

Here is the call graph for this function:

Here is the caller graph for this function:

results()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

const Sequence< const IScheduleMultiDim * > & gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::results ( ) const

finalvirtual

returns the ScheduleMultidim resulting from the operator

Warning

Note that the Operator always returns its outputs, even if it has not been executed. In this case, the outputs are abstract ScheduleMultiDim.

Returns

the sequence of ScheduleMultiDim resulting from the operator. Those can be abstract if the operator has not been performed yet.

Implements gum::ScheduleOperator.

References results().

Referenced by results().

Here is the call graph for this function:

Here is the caller graph for this function:

setCombinationFunction()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

void gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::setCombinationFunction

(

TABLE_RES(*

combine )(const TABLE1 &, const TABLE2 &)

)

use a new combination function

References setCombinationFunction().

Referenced by setCombinationFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

toString()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

std::string gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::toString ( ) const

finalvirtual

displays the content of the operator

Implements gum::ScheduleOperator.

References toString().

Referenced by toString().

Here is the call graph for this function:

Here is the caller graph for this function:

type()

ScheduleOperatorType gum::ScheduleOperator::type ( ) const

inherited

returns the type of the operator

Referenced by ScheduleOperator().

Here is the caller graph for this function:

undo()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

void gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::undo ( )

finalvirtual

undo a previous execution, if any

Implements gum::ScheduleOperator.

References undo().

Referenced by undo().

Here is the call graph for this function:

Here is the caller graph for this function:

updateArgs()

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

void gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::updateArgs ( const Sequence< const IScheduleMultiDim * > & new_args )

finalvirtual

modifies the arguments of the operator

Exceptions

SizeError	is raised if the number of elements in new_args does not correspond to the number of arguments expected by the ScheduleOperator.
TypeError	is raised if at least one element of new_args does not have a type compatible with what the ScheduleOperator expects.

Implements gum::ScheduleOperator.

References updateArgs().

Referenced by updateArgs().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_arg1_

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

const ScheduleMultiDim< TABLE1 >* gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::_arg1_ {nullptr}

private

the first argument of the combination

Definition at line 289 of file scheduleBinaryCombination.h.

{nullptr};

_arg2_

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

const ScheduleMultiDim< TABLE2 >* gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::_arg2_ {nullptr}

private

the second argument of the combination

Definition at line 292 of file scheduleBinaryCombination.h.

{nullptr};

_args_

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

Sequence< const IScheduleMultiDim* > gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::_args_

private

the sequence of arguments passed to the operator

This method is convenient when using ScheduleOperator rather than directly using ScheduleBinaryCombination

Definition at line 297 of file scheduleBinaryCombination.h.

_combine_

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

TABLE_RES(* gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::_combine_) (const TABLE1 &, const TABLE2 &)

private

the function actually used to perform the combination

Definition at line 310 of file scheduleBinaryCombination.h.

_imply_deletion_

bool gum::ScheduleOperator::_imply_deletion_

privateinherited

indicates whether the operator will delete some of the ScheduleMultiDim passed as its arguments

Definition at line 246 of file scheduleOperator.h.

_op_type_

ScheduleOperatorType gum::ScheduleOperator::_op_type_

privateinherited

the name of the operator to perform

Definition at line 242 of file scheduleOperator.h.

_result_

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

ScheduleMultiDim< TABLE_RES >* gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::_result_ {nullptr}

private

the result of the combination

Definition at line 300 of file scheduleBinaryCombination.h.

{nullptr};

_result_persistent_

bool gum::ScheduleOperator::_result_persistent_

privateinherited

is the result persistent

Definition at line 249 of file scheduleOperator.h.

_results_

template<typename TABLE1, typename TABLE2, typename TABLE_RES>

Sequence< const IScheduleMultiDim* > gum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES >::_results_

private

the sequence of ScheduleMultidim output by the operator

Warning

Note that the Operator has always some output, even if it has not been executed. In this case, the outputs are abstract ScheduleMultiDim.

Definition at line 307 of file scheduleBinaryCombination.h.

---

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

• agrum/base/graphicalModels/inference/scheduler/scheduleBinaryCombination.h