BcpsBranchObject.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.                                                      *
 *===========================================================================*/
   

//#############################################################################
// Borrow ideas from COIN/Cbc
//#############################################################################


#ifndef BcpsBranchObject_h_
#define BcpsBranchObject_h_

#include "BcpsModel.h"

#include "Alps.h"
#include "AlpsEncoded.h"


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


class BcpsBranchObject {
    
 protected:

    int type_;
    
    BcpsModel *model_;
    
    int objectIndex_;

    double upScore_;
    
    double downScore_;
    
    int direction_;
    
    double value_;
    
    int numBranchesLeft_;

 public:

    BcpsBranchObject()
        :
        type_(0),
        model_(NULL),
        objectIndex_(-1),
        upScore_(0),
        downScore_(0),
        direction_(0),
        value_(0.0),
        numBranchesLeft_(0)
        {}
    
    BcpsBranchObject(BcpsModel * model)
        :
        type_(0),
        model_(model),
        objectIndex_(-1),
        upScore_(0),
        downScore_(0),
        direction_(0),
        value_(0.0),
        numBranchesLeft_(2) 
        {}

    BcpsBranchObject(BcpsModel * model, 
                     int objectIndex, 
                     int direction , 
                     double value)
        :
        type_(0),
        model_(model),
        objectIndex_(objectIndex),
        upScore_(0),
        downScore_(0),
        direction_(direction),
        value_(value),
        numBranchesLeft_(2) 
        {}

    BcpsBranchObject(BcpsModel * model, 
                     int objectIndex, 
                     int upScore,
                     double downScore,
                     int direction , 
                     double value)
        :
        type_(0),
        model_(model),
        objectIndex_(objectIndex),
        upScore_(upScore),
        downScore_(downScore),
        direction_(direction),
        value_(value),
        numBranchesLeft_(2) 
        {}
    
    BcpsBranchObject (const BcpsBranchObject &);
    
    virtual ~BcpsBranchObject() { /* Do nothing */}
    
    BcpsBranchObject & operator = ( const BcpsBranchObject& rhs);

    virtual BcpsBranchObject * clone() const = 0;
  
    int getType() { return type_; }
    
    void setType(int t) { type_ = t; }

    virtual int numBranches() const { return 2; }
    
    virtual int numBranchesLeft() const { return numBranchesLeft_; }
    
    // THINK: what's the use of normalBranch?
    virtual double branch(bool normalBranch = false) = 0;
    
    virtual void print(bool normalBranch) {}

    virtual bool boundBranch() const { return true; }

    inline int getObjectIndex() const { return objectIndex_; }
    
    inline void setObjectIndex(int ind) {  objectIndex_ = ind; }
    
    inline double getUpScore() const { return upScore_; }

    inline void setUpScore(double score) { upScore_ = score; }
    
    inline double getDownScore() const { return downScore_; }    

    inline void setDownScore(double score) { downScore_ = score; }    
    
    inline int getDirection() const { return direction_; }

    inline void setDirection(int direction) { direction_ = direction; }
    
    inline double getValue() const { return value_; }
    
    inline BcpsModel * model() const { return  model_; }

 protected:

    AlpsReturnStatus encodeBcps(AlpsEncoded *encoded) const {
        AlpsReturnStatus status = AlpsReturnStatusOk;
        assert(encoded);
        encoded->writeRep(objectIndex_);
        encoded->writeRep(upScore_);
        encoded->writeRep(downScore_);
        encoded->writeRep(direction_);
        encoded->writeRep(value_);
        encoded->writeRep(numBranchesLeft_);

        return status;
    }

    AlpsReturnStatus decodeBcps(AlpsEncoded &encoded) {
        AlpsReturnStatus status = AlpsReturnStatusOk;

        encoded.readRep(objectIndex_);
        encoded.readRep(upScore_);
        encoded.readRep(downScore_);
        encoded.readRep(direction_);
        encoded.readRep(value_);
        encoded.readRep(numBranchesLeft_);

        return status;
    }

 public:

    virtual AlpsReturnStatus encode(AlpsEncoded *encoded) const {
        AlpsReturnStatus status = AlpsReturnStatusOk;
        // Should never be called.
        assert(0);
        return status;
    }

    virtual AlpsReturnStatus decode(AlpsEncoded &encoded) {
        AlpsReturnStatus status = AlpsReturnStatusOk;
        // Should never be called.
        assert(0);
        return status;
    }
    
};

#endif