separator.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/lib/abacus/hash.h>
 
#include <ogdf/lib/abacus/lpsolution.h>
#include <ogdf/lib/abacus/nonduplpool.h>
 
#pragma GCC visibility push(default)
namespace abacus {
 
 
enum Separator_CUTFOUND {Added, Duplication, Full};
 
 
 
template <class BaseType, class CoType>
class  Separator :  public AbacusRoot  {
public:
 
 
    Separator(
        LpSolution<CoType,BaseType> *lpSolution,
        bool nonDuplications,
        int maxGen=300)
        :
        master_(lpSolution->master_),
        lpSol_(lpSolution),
        minAbsViolation_(master_->eps()),
        newCons_(master_,maxGen),
        hash_(0),
        nDuplications_(0),
        pool_(0)
    {
        if(nonDuplications)
            hash_=new AbaHash<unsigned, BaseType *>((AbacusGlobal*)master_, 3*maxGen);
    }
 
 
    virtual ~Separator() {
        delete hash_;
    }
 
 
    virtual void separate() = 0;
 
 
    Separator_CUTFOUND cutFound(BaseType *cv);
 
 
    virtual bool terminateSeparation() {
        return ( nGen() >= maxGen() );
    }
 
    ArrayBuffer<BaseType *> &cutBuffer() { return newCons_; }
 
 
    int nGen() const { return newCons_.number(); }
 
 
    int nDuplications() const { return nDuplications_; }
 
 
    int nCollisions() const;
 
    int maxGen() const { return newCons_.size(); }
 
 
    double minAbsViolation() const { return minAbsViolation_; }
 
 
    void minAbsViolation(double minAbsVio) {
        minAbsViolation_=minAbsVio;
    }
 
    LpSolution<CoType, BaseType> *lpSolution() {
        return lpSol_;
    }
 
    void watchNonDuplPool(NonDuplPool<BaseType, CoType> *pool) {
        pool_ = pool;
    }
 
protected:
 
    bool find(BaseType *cv);
 
    Master *master_; 
    LpSolution<CoType, BaseType> *lpSol_; 
 
private:
    double minAbsViolation_;
    ArrayBuffer<BaseType*> newCons_;
    AbaHash<unsigned, BaseType*> *hash_;
    int nDuplications_;
    bool sendConstraints_;
    NonDuplPool<BaseType, CoType> *pool_;
 
    Separator(const Separator<BaseType, CoType> &rhs);
    const Separator<BaseType, CoType>
        &operator=(const Separator<BaseType, CoType> & rhs);
};
 
}
 
#include <ogdf/lib/abacus/separator.inc>
#pragma GCC visibility pop