template<class BaseType, class CoType>
class abacus::Pool< BaseType, CoType >
Base class for constraint/variabe pools.
Every constraint and variable has to to be stored in a pool. This class implements an abstract template class for a pool, which can be used to store objects of the class Variable or of the class Constraint. A constraint or variable is not directly stored in the pool, but in an PoolSlot. Hence, a pool is a collection of pool slots.
A pool has two template arguments: the BaseType and the CoType. Only two scenarios make sense in the current context. For a pool storing constraints the BaseType is Constraint and the CoType is Variable. For a pool storing variables the BaseType is Variable and the corresponding CoType is Constraint.
The class Pool is an abstract class from which concrete classes have to be derived, implementing the data structures for the storage of pool slots. We provide already in the class StandardPool a simple but convenient implementation of a pool. We refer to all constraints and variables via the class PoolSlotRef.
Definition at line 62 of file pool.h.
template<class BaseType , class CoType >
Determines how th rank of a constraint/variable is computed.
The enumeration RANKING indicates how the rank of a constraint/variable in a pool separation is determined. This enumeration is not used at the moment because we cannot use the enumeration as the type of a function parameter in a derived class.
Enumerator 

NO_RANK  No rank is computed.

RANK  The violation computed by the function violated() of the classes Constraint or Variable is used as rank.

ABS_RANK  The absolute value of the violation is taken as rank.

Definition at line 73 of file pool.h.
template<class BaseType , class CoType >
virtual int abacus::Pool< BaseType, CoType >::separate 
( 
double * 
z, 


Active< CoType, BaseType > * 
active, 


Sub * 
sub, 


CutBuffer< BaseType, CoType > * 
cutBuffer, 


double 
minAbsViolation = 0.001 , 


int 
ranking = 0 

) 
 

pure virtual 
Checks if a pair of a vector and an active constraint/variable set violates any item in the pool.
If the pool is a constraint pool, then the vector is an LPsolution and the active set is the set of active variables. Otherwise, if the pool is a variable pool, then the vector contains the dual variables and the active set is the set of associated active constraints.
 Parameters

z  The vector for which violation is checked. 
active  The constraint/variable set associated with z. 
sub  The subproblem for which validity of the violated item is required. 
cutBuffer  The violated constraints/variables are added to this buffer. 
minAbsViolation  A violated constraint/variable is only added to the cutBuffer if the absolute value of its violation is at least minAbsViolation. The default value is 0.001. 
ranking  If 1, the violation is associated with a rank of item in the buffer, if 2 the absolute violation is used, if 0 no rank is associated with the item. 
 Returns
 The number of violated items.
template<class BaseType , class CoType >
virtual int abacus::Pool< BaseType, CoType >::softDeleteConVar 
( 
PoolSlot< BaseType, CoType > * 
slot  ) 


inlineprotectedvirtual 
Removes the constraint/variable stored in slot from the pool if it can be deleted.
If the constraint/variable can be removed, the slot is added to the set of free slots.
 Parameters

slot  A pointer to the pool slot from wich the constraint/variable should be deleted. 
 Returns
 0 if the constraint/variable could be deleted.

1 otherwise.
Definition at line 154 of file pool.h.