separator.inc

Go to the documentation of this file.

#ifndef ABA_SEPARATOR_INC
#define ABA_SEPARATOR_INC

#include "abacus/separator.h"
#include "abacus/lpsolution.h"
#include "abacus/constraint.h"
#include "abacus/variable.h"
#include "abacus/hash.h"
#include "abacus/master.h"

  template <class BaseType, class CoType> 
  ABA_SEPARATOR<BaseType, CoType>::ABA_SEPARATOR(ABA_LPSOLUTION<CoType,
    BaseType> *lpSolution, bool testDuplications, int maxGen
#ifdef ABACUS_PARALLEL
    ,bool sendConstraints
#endif
          )

  :  
  master_(lpSolution->master_), 
  lpSol_(lpSolution), 
  minAbsViolation_(master_->eps()), 
  newCons_(master_,maxGen), 
  hash_(0),
  nDuplications_(0),
#ifdef ABACUS_PARALLEL
  sendConstraints_(sendConstraints),
#endif
  pool_(0)
  { 
  if(testDuplications)
    hash_=new ABA_HASH<unsigned, BaseType *>((ABA_GLOBAL*)master_, 3*maxGen);
}

  template <class BaseType, class CoType>
  ABA_SEPARATOR<BaseType, CoType>::~ABA_SEPARATOR()
  {
    delete hash_;
  }

  template <class BaseType, class CoType>
  ABA_SEPARATOR_CUTFOUND 
  ABA_SEPARATOR<BaseType, CoType>::cutFound(BaseType *cv)
  {
  if(newCons_.full()) {
    delete cv;
    return Full;
  }

  if(pool_&&pool_->present(cv)) {
    delete cv;
    nDuplications_++;
    return Duplication;
  }   

  if(hash_&&find(cv)) {
    delete cv;
    nDuplications_++;
    return Duplication;
  }
   

  newCons_.push(cv);
  if(hash_)
    hash_->insert(cv->hashKey(),cv);
  return Added;
  }

  template <class BaseType, class CoType>
   ABA_BUFFER<BaseType *> &ABA_SEPARATOR<BaseType, CoType>::cutBuffer() 
  {
    return newCons_;
  }

  template <class BaseType, class CoType>
  int ABA_SEPARATOR<BaseType, CoType>::nGen() const
  {
  return newCons_.number();
  }

  template <class BaseType, class CoType>
  int ABA_SEPARATOR<BaseType, CoType>::nDuplications() const
  {
  return nDuplications_;
  }

  template <class BaseType, class CoType>
  int ABA_SEPARATOR<BaseType, CoType>::nCollisions() const
  {
  if(!hash_)
    return 0;   
  return hash_->nCollisions();
  }

  template <class BaseType, class CoType>
  int ABA_SEPARATOR<BaseType, CoType>::maxGen() const
  {
  return newCons_.size();
  }

  virtual void separate()

  virtual bool terminateSeparation()
 
  template <class BaseType, class CoType>
  bool ABA_SEPARATOR<BaseType, CoType>::find(BaseType *cv) 
  {
   int key = cv->hashKey();

   BaseType **cand = hash_->initializeIteration(key);

   while(cand) {
      if (cv->equal(*cand)) return true;
      cand = hash_->next(key);
    }
    return false;
 }

  template <class BaseType, class CoType>
  double ABA_SEPARATOR<BaseType, CoType>::minAbsViolation() const
  {
    return minAbsViolation_;
  }

  void minAbsViolation(double minAbsVio)
 
  ABA_LPSOLUTION<CoType, BaseType> *lpSolution()        

void watchNonDuplPool(ABA_NONDUPLPOOL<BaseType, CoType> *pool)

#endif   // ABA_SEPERATOR_INC

---