/home/coin/SVN-release/CoinAll-1.1.0/Bcp/src/include/BCP_var.hpp

Go to the documentation of this file.

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

// This file is fully docified.

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

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

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

// Generic variable definition.

class BCP_var{
private:
    BCP_var();
    BCP_var(const BCP_var&);
    BCP_var& operator=(const BCP_var&);
private:
    int  _bcpind;
    BCP_obj_status _status;
protected:
    BCP_var_t _var_type;
    double    _obj;
    double    _lb;
    double    _ub;
public:
    BCP_var(const BCP_var_t var_type,
            const double obj, const double lb, const double ub) :
       _bcpind(0), _status(BCP_ObjNoInfo),
       _var_type(var_type), _obj(obj), _lb(lb), _ub(ub) {}
    virtual ~BCP_var() {}
    virtual BCP_object_t obj_type() const = 0;
    inline BCP_var_t var_type() const   { return _var_type; }
    inline double obj() const           { return _obj; }
    inline double lb() const            { return _lb; }
    inline double ub() const            { return _ub; }
    inline int bcpind() const { return _bcpind; }

      inline BCP_obj_status status() const   { return _status; }
      inline bool dont_send_to_pool() const {
        return _status & BCP_ObjDoNotSendToPool ? true : false;
      }
      inline bool is_fixed() const {
        return (_status & BCP_ObjInactive) != 0;
      }
      inline bool is_fixed_to_zero() const {
        return (_status & BCP_ObjInactive) && _lb == 0;
      }
      inline bool is_non_removable() const {
        return (_status & BCP_ObjNotRemovable) ? true : false;
      }
      inline bool is_removable() const {
        return (_status & BCP_ObjNotRemovable) ? false : is_fixed_to_zero();
      }
      inline bool is_to_be_removed() const {
        return (_status & BCP_ObjToBeRemoved) != 0;
      }

    inline void test_inactive() {
      if (_ub - _lb < 1e-8)
        _status = static_cast<BCP_obj_status>(_status | BCP_ObjInactive);
    }
    inline void set_var_type(const BCP_var_t type) { _var_type = type; }
    inline void set_obj(const double obj)          { _obj = obj; }
    inline void set_lb(const double lb)            {
      _lb = lb;
      test_inactive();
    }
    inline void set_ub(const double ub)            {
      _ub = ub;
      test_inactive();
    }
    inline void change_lb_ub_st(const BCP_obj_change& change) {
       _lb = change.lb;
       _ub = change.ub;
       _status = change.stat;
       test_inactive();
    }
    inline void change_bounds(const double lb, const double ub) {
       _lb = lb;
       _ub = ub;
       test_inactive();
    }
    inline void set_bcpind(const int bcpind)  { _bcpind = bcpind; }

      inline void set_status(const BCP_obj_status status) { _status = status; }
      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;
      }
    void display(const double val) const;
};

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

class BCP_var_core : public BCP_var {
private:
   BCP_var_core();
   BCP_var_core& operator=(const BCP_var_core&);
public:
   BCP_var_core(const BCP_var_core& x) :
      BCP_var(x._var_type, x._obj, x._lb, x._ub) {
      set_bcpind(x.bcpind());
      set_status(x.status());
   }
   BCP_var_core(const BCP_var_t var_type,
                const double obj, const double lb, const double ub) :
      BCP_var(var_type, obj, lb, ub) {}
   ~BCP_var_core() {}
   inline BCP_object_t obj_type() const  { return BCP_CoreObj; }
};

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

class BCP_var_indexed : public BCP_var {
private:
   int _index;  
private:
   BCP_var_indexed();
   BCP_var_indexed(const BCP_var_indexed&);
   BCP_var_indexed& operator=(const BCP_var_indexed&);
public:
   BCP_var_indexed(const int index, const BCP_var_t var_type,
                   const double obj, const double lb, const double ub) :
      BCP_var(var_type, obj, lb, ub), _index(index) {}
   ~BCP_var_indexed() {}
   inline int index() const               { return _index; }
   inline BCP_object_t obj_type() const   { return BCP_IndexedObj; }
};

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

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

class BCP_var_algo : public BCP_var {
private:
   BCP_var_algo();
   BCP_var_algo(const BCP_var_algo&);
   BCP_var_algo& operator=(const BCP_var_algo&);
public:
   BCP_var_algo(const BCP_var_t var_type,
                const double obj, const double lb, const double ub) :
      BCP_var(var_type, obj, lb, ub) {}
   virtual ~BCP_var_algo() = 0;
   inline BCP_object_t obj_type() const   { return BCP_AlgoObj; }
};

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

class BCP_var_set : public BCP_vec<BCP_var*> {
private:
   BCP_var_set(const BCP_var_set&);
   BCP_var_set& operator=(const BCP_var_set&);
public:
   BCP_var_set() {}
   ~BCP_var_set() {}
   inline void append(const BCP_vec<BCP_var*>& x) {
      BCP_vec<BCP_var*>::append(x);
   }
   inline void append(BCP_var_set::const_iterator first,
                      BCP_var_set::const_iterator last){
      BCP_vec<BCP_var*>::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>& vc);
   void set_lb_ub_st(BCP_vec<int>::const_iterator pos,
                     const BCP_vec<BCP_obj_change>& vc);
   //--------------------------------------------------------------------------
   void deletable(const int bvarnum, BCP_vec<int>& collection);
   // *FIXME* shouldn't we keep a local var pool in the lp process and move
   // deletables to this pool? compare w/ cuts...
   //--------------------------------------------------------------------------
};

#endif

---