/home/coin/SVN-release/CoinAll-1.1.0/Bcps/examples/Blis/BlisBranchObjectInt.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Bcps Linear Solver (BLIS).                       *
 *                                                                           *
 * BLIS is distributed under the Common 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-2005, International Business Machines                  *
 * Corporation, Lehigh University, Yan Xu, Ted Ralphs, Matthew Salzman and   *
 * others. All Rights Reserved.                                              *
 *===========================================================================*/


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


#include "BcpsBranchObject.h"

#include "BlisModel.h"


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


class BlisBranchObjectInt : public BcpsBranchObject {

 protected:

    double down_[2];
    
    double up_[2];

 public:
    
    BlisBranchObjectInt()    
        : 
        BcpsBranchObject()
        {
            type_ = BLIS_BO_INT;
            down_[0] = 0.0;
            down_[1] = 0.0;
            up_[0] = 0.0;
            up_[1] = 0.0;
        }

    BlisBranchObjectInt(BlisModel * model, 
                        int varInd,
                        int direction,
                        double value)
        : 
        BcpsBranchObject(model, varInd, direction, value)
        {
            type_ = BLIS_BO_INT;
            int iColumn = model->getIntVars()[objectIndex_];
            down_[0] = model->solver()->getColLower()[iColumn];
            down_[1] = floor(value_);
            up_[0] = ceil(value_);
            up_[1] = model->getColUpper()[iColumn];
        }

    BlisBranchObjectInt(BlisModel * model,
                        int varInd,
                        int intScore,
                        double dblScore,
                        int direction,
                        double value)
        : 
        BcpsBranchObject(model, varInd, intScore, dblScore, direction, value)
        {
            type_ = BLIS_BO_INT;
            int iColumn = model->getIntVars()[objectIndex_];
            down_[0] = model->solver()->getColLower()[iColumn];
            down_[1] = floor(value_);
            up_[0] = ceil(value_);
            up_[1] = model->getColUpper()[iColumn];
        }
    
    BlisBranchObjectInt(BlisModel * model,
                        int varInd, 
                        int direction,
                        double lowerValue, 
                        double upperValue)
        :
        BcpsBranchObject(model, varInd, direction, lowerValue)
        {
            type_ = BLIS_BO_INT;
            numBranchesLeft_ = 1;
            down_[0] = lowerValue;
            down_[1] = upperValue;
            up_[0] = lowerValue;
            up_[1] = upperValue;
        }
  
    BlisBranchObjectInt(const BlisBranchObjectInt &);
    
    BlisBranchObjectInt & operator = (const BlisBranchObjectInt& rhs);
    
    virtual BcpsBranchObject * clone() const {
        return (new BlisBranchObjectInt(*this));
    }

    virtual ~BlisBranchObjectInt() {}
  
    virtual double branch(bool normalBranch = false);

    virtual void print(bool normalBranch);

    const double *getDown() const { return down_; }

    const double *getUp() const { return up_; }

 protected:

    AlpsReturnStatus encodeBlis(AlpsEncoded *encoded) const {
        assert(encoded);
        AlpsReturnStatus status = AlpsReturnStatusOk;
        int j;
        // TODO: N-way.
        for (j = 0; j < 2; ++j) {
            encoded->writeRep(down_[j]);
        }
        for (j = 0; j < 2; ++j) {
            encoded->writeRep(up_[j]);
        }
        
        return status;
    }

    AlpsReturnStatus decodeBlis(AlpsEncoded &encoded) {
        AlpsReturnStatus status = AlpsReturnStatusOk;
        int j;
        // TODO: N-way.
        for (j = 0; j < 2; ++j) {
            encoded.readRep(down_[j]);
        }
        for (j = 0; j < 2; ++j) {
            encoded.readRep(up_[j]);
        }
        
        return status;
    }

 public:

    virtual AlpsReturnStatus encode(AlpsEncoded *encoded) const {
        AlpsReturnStatus status = AlpsReturnStatusOk;

        status = encodeBcps(encoded);
        status = encodeBlis(encoded);
        
        return status;
    }

    virtual AlpsReturnStatus decode(AlpsEncoded &encoded) {
        
        AlpsReturnStatus status = AlpsReturnStatusOk;

        status = decodeBcps(encoded);
        status = decodeBlis(encoded);
        
        return status;
    }
    
};

---