BcpsObject.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Branch, Constrain and Price Software (BiCePS)    *
 *                                                                           *
 * BiCePS is distributed under the Eclipse Public License as part of the     *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           *
 * Copyright (C) 2001-2013, Lehigh University, Yan Xu, and Ted Ralphs.       *
 * All Rights Reserved.                                                      *
 *===========================================================================*/

#ifndef BcpsObject_h_
#define BcpsObject_h_

#include "Alps.h"
#include "AlpsKnowledge.h"

#include "Bcps.h"

class BcpsModel;
class BcpsBranchObject;

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

#define    BCPS_NONREMOVALBE 0x0001
#define    BCPS_BRACNEDON    0x0010
#define    BCPS_SENDABLE     0x0100

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

typedef char BcpsIntegral_t;
//#############################################################################
//#############################################################################

enum BcpsObject_t {
    BCPS_PRIMAL_OBJECT = 0,
    BCPS_VAR_OBJECT = 0,
    BCPS_DUAL_OBJECT = 1,
    BCPS_CON_OBJECT = 1
};

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

enum BcpsObjRep_t {
    BCPS_CORE = 0,
    BCPS_INDEXED = 1,
    BCPS_ALGO = 2
};

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

class BcpsObject : public AlpsKnowledge {

 protected:

    int objectIndex_;
    
    BcpsObjRep_t repType_;
    
    BcpsIntegral_t intType_;

    BcpsValidRegion validRegion_;

    // branched on? non-removable ? can it be sent to the pool?
    // do we need it at all?
    int status_;
    
    double lbHard_;
    
    double ubHard_;
    
    double lbSoft_;
    
    double ubSoft_;
    
    double hashValue_;

    int numInactive_;

    double effectiveness_;
    
 public:

    BcpsObject()
        :
        objectIndex_(-1),
        repType_(BCPS_CORE),
        intType_('C'),
        validRegion_(BcpsValidLocal),
        status_(0),
        lbHard_(0.0),
        ubHard_(0.0),
        lbSoft_(0.0),
        ubSoft_(0.0),
        hashValue_(0.0),
        numInactive_(0),
        effectiveness_(-ALPS_DBL_MAX)
        {}
    
    BcpsObject(double lbh, double ubh, double lbs, double ubs) 
        :
        objectIndex_(-1),
        repType_(BCPS_CORE),
        intType_('C'),
        validRegion_(BcpsValidLocal),
        status_(0),
        lbHard_(lbh),
        ubHard_(ubh),
        lbSoft_(lbs),
        ubSoft_(ubs),
        hashValue_(0.0),
        numInactive_(0),
        effectiveness_(-ALPS_DBL_MAX)
        {}

    virtual ~BcpsObject() {}

    BcpsObject (const BcpsObject & rhs) {
        objectIndex_ = rhs.objectIndex_;
        repType_ = rhs.repType_;
        intType_ = rhs.intType_;
        validRegion_ = rhs.validRegion_,
        status_ = rhs.status_;
        lbHard_ = rhs.lbHard_;
        ubHard_ = rhs.ubHard_;
        lbSoft_ = rhs.lbSoft_;
        ubSoft_ = rhs.ubSoft_;
        hashValue_ = rhs.hashValue_;
        numInactive_ = rhs.numInactive_;
        effectiveness_ = rhs.effectiveness_;
    }

    BcpsObject & operator = ( const BcpsObject& rhs);
    
    virtual BcpsObject * clone() const {
        BcpsObject * be = NULL;
        return be;
    }

    inline int getObjectIndex() const         { return objectIndex_; }
    inline BcpsObjRep_t getRepType() const    { return repType_; }
    inline BcpsIntegral_t getIntType() const  { return intType_; }
    inline BcpsValidRegion getValidRegion() const  { return validRegion_; }
    inline int getStatus() const              { return status_; }
    inline double getLbHard() const           { return lbHard_; }
    inline double getUbHard() const           { return ubHard_; }
    inline double getLbSoft() const           { return lbSoft_; }
    inline double getUbSoft() const           { return ubSoft_; }
    inline int getNumInactive() const         { return numInactive_; }
    inline double getEffectiveness() const    { return effectiveness_; }
    inline void setObjectIndex(int ind)       { objectIndex_ = ind; }    
    inline void setRepType(BcpsObjRep_t rt)   { repType_ = rt; }
    inline void setIntType(BcpsIntegral_t it) { intType_ = it; }
    inline void setValidRegion(BcpsValidRegion val) { validRegion_ = val;} 
    inline void setStatus(int st)             { status_ |= st; }
    inline void setLbHard(double lb)          { lbHard_ = lb; }
    inline void setUbHard(double ub)          { ubHard_ = ub; }
    inline void setLbSoft(double lb)          { lbSoft_ = lb; }
    inline void setUbSoft(double ub)          { ubSoft_ = ub; }
    inline void setNumInactive(int num)       { numInactive_ = num; }
    inline void setEffectiveness(double eff)  { effectiveness_= eff; }
    virtual void hashing(BcpsModel *model=NULL)    { hashValue_ = 0.0; }
    double hashValue() const  {  return hashValue_; }
    virtual double infeasibility(BcpsModel *m, int &preferredWay) const {
        return 0.0; 
    }
    
    virtual void feasibleRegion(BcpsModel *m) {}
    
    virtual BcpsBranchObject * createBranchObject(BcpsModel *m, int way) const{
        BcpsBranchObject *be = NULL;
        return be;
    }
    
    virtual BcpsBranchObject * preferredNewFeasible(BcpsModel *m) const {
        BcpsBranchObject * temp = NULL; 
        return temp; 
    }
  
    virtual BcpsBranchObject * notPreferredNewFeasible(BcpsModel *m) const { 
        BcpsBranchObject * temp = NULL; 
        return temp; 
    }
    
    virtual void resetBounds(BcpsModel *m) {}
    
    virtual bool boundBranch(BcpsModel *m) const { return true; }
    
    virtual void floorCeiling(double &floorValue, 
                              double &ceilingValue, 
                              double value,
                              double tolerance) const;
    
    virtual double upEstimate() const { return 1.0e-5; }
    
    virtual double downEstimate() const { return 1.0e-5; }

    virtual void printDesc() {}
    
 protected:
    
    AlpsReturnStatus encodeBcpsObject(AlpsEncoded *encoded) const {
        AlpsReturnStatus status = AlpsReturnStatusOk;
        encoded->writeRep(objectIndex_);
        encoded->writeRep(repType_);
        encoded->writeRep(intType_);
        encoded->writeRep(validRegion_);
        encoded->writeRep(status_);
        encoded->writeRep(lbHard_);
        encoded->writeRep(ubHard_);
        encoded->writeRep(lbSoft_);
        encoded->writeRep(ubSoft_);
        encoded->writeRep(hashValue_);
        return status;
    }

    AlpsReturnStatus decodeBcpsObject(AlpsEncoded &encoded){
        AlpsReturnStatus status = AlpsReturnStatusOk;
        encoded.readRep(objectIndex_);
        encoded.readRep(repType_);
        encoded.readRep(intType_);
        encoded.readRep(validRegion_);
        encoded.readRep(status_);
        encoded.readRep(lbHard_);
        encoded.readRep(ubHard_);
        encoded.readRep(lbSoft_);
        encoded.readRep(ubSoft_);
        encoded.readRep(hashValue_);
        return status;
    }

protected:
    
 public:

    using AlpsKnowledge::encode ;
    virtual AlpsReturnStatus encode(AlpsEncoded *encoded) {
        AlpsReturnStatus status = AlpsReturnStatusOk;
        assert(0);
        return status;
    }
   
    virtual AlpsKnowledge* decode(AlpsEncoded& encoded) const {
        AlpsKnowledge* know = NULL;
        assert(0);
        return know;
    }
};


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


typedef BcpsObject*  BcpsObject_p;


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


class BcpsConstraint : public BcpsObject {

 public:
    BcpsConstraint() : BcpsObject() { setType(BcpsKnowledgeTypeConstraint); }

    BcpsConstraint(double lbh, double ubh, double lbs, double ubs) 
        :
        BcpsObject(lbh, ubh, lbs, ubs)
        { setType(BcpsKnowledgeTypeConstraint); }
        
    virtual ~BcpsConstraint() {}

    BcpsConstraint(const BcpsConstraint & rhs) 
        :
        BcpsObject(rhs)
        {}    
    
    inline virtual BcpsObject_t getObjType() const { return BCPS_CON_OBJECT; }
};


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


class BcpsVariable : public BcpsObject {
 public:
    BcpsVariable() : BcpsObject() { setType(BcpsKnowledgeTypeVariable); }

    BcpsVariable(double lbh, double ubh, double lbs, double ubs) 
        :
        BcpsObject(lbh, ubh, lbs, ubs)
        { setType(BcpsKnowledgeTypeVariable); }

    virtual ~BcpsVariable() {}

    BcpsVariable(const BcpsVariable & rhs) 
        :
        BcpsObject(rhs)
        {}

    inline virtual BcpsObject_t getObjType() const { return BCPS_VAR_OBJECT; }
};


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

#endif