BCP_cut.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef _BCP_CUT_H
#define _BCP_CUT_H

// This file is fully docified.

//#############################################################################

#include "CoinSmartPtr.hpp"
#include "BCP_math.hpp"
#include "BCP_error.hpp"
#include "BCP_enum.hpp"
#include "BCP_vector.hpp"
#include "BCP_obj_change.hpp"

//#############################################################################

// Generic cut definition

class BCP_cut : public Coin::ReferencedObject {
private:
    BCP_cut();
    BCP_cut(const BCP_cut&);
    BCP_cut& operator=(const BCP_cut&);
private:
    int  _bcpind;
    BCP_obj_status _status;
    int            _eff_cnt;
protected:
    double         _lb;
    double         _ub;
public:
    BCP_cut(const double lb, const double ub) :
       _bcpind(0), _status(BCP_ObjNoInfo), _eff_cnt(0), _lb(lb), _ub(ub) {}
    virtual ~BCP_cut() {}
    virtual BCP_object_t obj_type() const = 0;
    inline int effective_count() const   { return _eff_cnt; }
    inline double lb() const             { return _lb; }
    inline double ub() const             { return _ub; }
    inline int bcpind() const  { return _bcpind; }

    /* *@name Query methods about the status of the variable */
    /* @{*/
      inline BCP_obj_status status() const { return _status; }
      inline bool dont_send_to_pool() const {
         return _status & BCP_ObjDoNotSendToPool ? true : false;
      }
      inline bool is_non_removable() const {
         return (_status & BCP_ObjNotRemovable) ? true : false;
      }
      inline bool is_to_be_removed() const {
         return (_status & BCP_ObjToBeRemoved) != 0;
      }
    /* @}*/
    inline void set_effective_count(const int cnt) { _eff_cnt = cnt; }
    inline int increase_effective_count() {
       _eff_cnt = _eff_cnt <= 0 ? 1 : _eff_cnt + 1;
       return _eff_cnt;
    }
    inline int decrease_effective_count() {
       _eff_cnt = _eff_cnt >= 0 ? -1 : _eff_cnt - 1;
       return _eff_cnt;
    }
    inline void set_lb(const double lb) { _lb = lb; }
    inline void set_ub(const double ub) { _ub = ub; }
    inline void change_lb_ub_st(const BCP_obj_change& change) {
       _lb = change.lb;
       _ub = change.ub;
       _status = change.stat;
       if (_lb < -BCP_DBL_MAX/10 && _ub > BCP_DBL_MAX/10)
         _status = static_cast<BCP_obj_status>(_status | BCP_ObjInactive);
    }
    inline void change_bounds(const double lb, const double ub) {
       _lb = lb;
       _ub = ub;
       if (lb < BCP_DBL_MAX/10 && ub > BCP_DBL_MAX/10)
         _status = static_cast<BCP_obj_status>(_status | BCP_ObjInactive);
    }
    inline void set_bcpind(const int bcpind)  { _bcpind = bcpind; }
    inline void set_bcpind_flip()  { _bcpind = -_bcpind; }

    /* *@name Status modifying methods */
    /* @{*/
      inline void set_status(const BCP_obj_status stat) { _status = stat; }
      inline void dont_send_to_pool(bool flag) {
         _status = static_cast<BCP_obj_status>(flag ?
                                            _status | BCP_ObjDoNotSendToPool :
                                            _status & ~BCP_ObjDoNotSendToPool);
      }
      inline void make_active() {
         _status = static_cast<BCP_obj_status>(_status & ~BCP_ObjInactive);
      }
      inline void make_non_removable() {
         _status =
           static_cast<BCP_obj_status> ((_status & ~BCP_ObjToBeRemoved) |
                                        BCP_ObjNotRemovable);
      }
      inline void make_to_be_removed() {
         _status = BCP_ObjToBeRemoved;
      }
    /* @}*/
};

//#############################################################################
//#############################################################################

class BCP_cut_core : public BCP_cut {

private:
   BCP_cut_core();
   BCP_cut_core& operator=(const BCP_cut_core&);
public:
   BCP_cut_core(const BCP_cut_core& x) : BCP_cut(x._lb, x._ub) {
      set_bcpind(x.bcpind());
      set_status(x.status());
      set_effective_count(x.effective_count());
   }
   BCP_cut_core(const double lb, const double ub) : BCP_cut(lb, ub) {}
   ~BCP_cut_core() {}
   inline BCP_object_t obj_type() const  { return BCP_CoreObj; }
};

//#############################################################################

// This is the class the user should derive his/her own algorithmic cuts

class BCP_cut_algo : public BCP_cut {
private:
   BCP_cut_algo();
   BCP_cut_algo(const BCP_cut_algo&);
   BCP_cut_algo& operator=(const BCP_cut_algo&);
public:
   BCP_cut_algo(const double lb, const double ub) : BCP_cut(lb, ub) {}
   virtual ~BCP_cut_algo() = 0;
   inline BCP_object_t obj_type() const   { return BCP_AlgoObj; }
};

//#############################################################################
//#############################################################################

class BCP_cut_set : public BCP_vec<BCP_cut*> {
private:
   BCP_cut_set(const BCP_cut_set&);
   BCP_cut_set& operator=(const BCP_cut_set&);
public:
    BCP_cut_set() {}
   ~BCP_cut_set() {}
   inline void append(const BCP_vec<BCP_cut*>& x) {
      BCP_vec<BCP_cut*>::append(x);
   }
   inline void append(BCP_cut_set::const_iterator first,
                      BCP_cut_set::const_iterator last){
      BCP_vec<BCP_cut*>::append(first, last);
   }

   void set_lb_ub(const BCP_vec<int>& pos,
                  BCP_vec<double>::const_iterator bounds);
   void set_lb_ub_st(const BCP_vec<BCP_obj_change>& cc);
   void set_lb_ub_st(BCP_vec<int>::const_iterator pos,
                     const BCP_vec<BCP_obj_change>& cc);
#if 0
   //--------------------------------------------------------------------------
   void nonzero_slack(int first_to_check, const double * slacks,
                      const double etol, const int ineff_limit,
                      BCP_vec<int>& coll);
   void zero_dual(int first_to_check, const double * duals,
                  const double etol, const int ineff_limit,
                  BCP_vec<int>& coll);
#endif

#if 0

   void deletable(const int bcutnum, BCP_vec<int>& collection) const;
#endif

   void move_deletable_to_pool(const BCP_vec<int>& deletable_cuts,
                               BCP_vec<BCP_cut*>& pool);
   //-----------------------------------------------------------------------
};

#endif