BcpsBranchStrategy.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 BcpsBranchStrategy_h_
#define BcpsBranchStrategy_h_

#include "BcpsBranchObject.h"

class BcpsModel;

//#############################################################################
// NOTE: Borrow ideas from COIN/Cbc.
//#############################################################################


class BcpsBranchStrategy {
    
 private:
    BcpsBranchStrategy & operator=(const BcpsBranchStrategy& rhs);
    
 protected:

    int type_;
    
    BcpsModel *model_;

    int numBranchObjects_;
    BcpsBranchObject ** branchObjects_;
    
    BcpsBranchObject * bestBranchObject_;
    double bestChangeUp_;
    int bestNumberUp_;
    double bestChangeDown_;
    int bestNumberDown_;

 public:

    BcpsBranchStrategy()
        :
        model_(NULL),
        numBranchObjects_(0),
        branchObjects_(NULL),
        bestChangeUp_(0.0),
        bestNumberUp_(0),
        bestChangeDown_(0.0),
        bestNumberDown_(0)
        {}

    BcpsBranchStrategy(BcpsModel *m)
        :
        model_(m),
        numBranchObjects_(0),
        branchObjects_(NULL),
        bestChangeUp_(0.0),
        bestNumberUp_(0),
        bestChangeDown_(0.0),
        bestNumberDown_(0)
        {}
    
    virtual ~BcpsBranchStrategy() {
        for (int k = 0; k < numBranchObjects_; ++k) {
            delete branchObjects_[k];
        }
        delete [] branchObjects_;
    }
    
    virtual BcpsBranchStrategy * clone() const = 0;
    
    int getType() { return type_; }
    
    void setType(int t) { type_ = t; }

    void setModel(BcpsModel *m) { model_ = m; }

    int getNumBranchObjects() { return numBranchObjects_; }
    void getNumBranchObjects(int num) { numBranchObjects_ = num; }
    BcpsBranchObject ** getBranchObjects() { return branchObjects_; }
    void setBranchObjects(BcpsBranchObject **obj) { branchObjects_ = obj; }
    BcpsBranchObject *getBestBranchObject() { return bestBranchObject_; }
    void setBestBranchObject(BcpsBranchObject *ob) { bestBranchObject_ = ob; }

    virtual void clearBest(BcpsModel * model) {
        bestBranchObject_ = NULL;
        bestChangeUp_ = 0.0;
        bestNumberUp_ = 0;
        bestChangeDown_ = 0.0;
        bestNumberDown_ = 0;
    }

    virtual int createCandBranchObjects(int numPassesLeft, double ub){ 
        return 0; 
    }
    
    virtual int betterBranchObject(BcpsBranchObject * b,
                                   BcpsBranchObject * bestSoFar) = 0;
    
    virtual BcpsBranchObject *bestBranchObject();
};

#endif