AbcNodeDesc.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Abstract Library for Parallel Search (ALPS).     *
 *                                                                           *
 * ALPS 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.       *
 *===========================================================================*/

//#############################################################################
// This file is modified from SbbNode.hpp
//#############################################################################

#ifndef AbcNodeDesc_h_
#define AbcNodeDesc_h_

#include "CoinHelperFunctions.hpp"
#include "CoinWarmStartBasis.hpp"

#include "AlpsNodeDesc.h"
#include "AbcModel.h"

class OsiSolverInterface;

class OsiCuts;
class OsiRowCut;
class OsiRowCutDebugger;

class AbcModel;
class AbcNode;

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


class AbcNodeDesc : public AlpsNodeDesc {
  
 private:
    
    /* Here, we need to fill in what the node description will look
       like. For now, we will not use differencing -- just explicitly
       represent it. Probably this means that we will just store the
       original problem data and a list of the variables that have been
       fixed. */
    
    double* lowerBounds_;
    double* upperBounds_;
    
    int numberRows_;
    int numberCols_;

    int branchedOn_;

    double branchedOnVal_;

    int branchedDir_;    
 public:
    AbcNodeDesc()
    :
    AlpsNodeDesc(0),
    lowerBounds_(0), 
    upperBounds_(0),
    numberRows_(0),
    numberCols_(0),
    branchedOn_(-8),
    branchedOnVal_(0),
    branchedDir_(1)
    {
    }

    AbcNodeDesc(AbcModel* m) 
    :
    AlpsNodeDesc(m),
    lowerBounds_(0), 
    upperBounds_(0),
    numberRows_(0),
    numberCols_(0),
    branchedOn_(-9),
    branchedOnVal_(0),
    branchedDir_(1)
    {
    }  
  
    AbcNodeDesc(AbcModel* m, const double* lb, const double* ub) 
    :
    AlpsNodeDesc(m),
    branchedOn_(-10),
    branchedOnVal_(0),
    branchedDir_(1)
    {
        numberRows_ = m->solver()->getNumRows();
        numberCols_ = m->solver()->getNumCols();
        assert(numberRows_ && numberCols_);
        lowerBounds_ = new double [numberCols_];
        upperBounds_ = new double [numberCols_];
        memcpy(lowerBounds_, lb, sizeof(double)*numberCols_);
        memcpy(upperBounds_, ub, sizeof(double)*numberCols_);
    }
  
    virtual ~AbcNodeDesc() { 
    if (lowerBounds_ != 0) {
        delete [] lowerBounds_;
        lowerBounds_ = 0;
    }
    if (upperBounds_ != 0) {
        delete [] upperBounds_;
        upperBounds_ = 0;
    }
    }

    double* lowerBounds()
    {
        if(lowerBounds_ == 0) {
        assert(model_);
        AbcModel* m = dynamic_cast<AbcModel*>(model_);
        const int num = m->getNumCols();
        const double* lb = m->getColLower();
        lowerBounds_ = new double [num];
        memcpy(lowerBounds_, lb, sizeof(double)*num);
//      std::cout << "AbcNodeDesc::lowerBounds--num=" << num 
//            <<std::endl;
        }    
        return lowerBounds_;
    }
    
    void setLowerBounds(const double* lb, const int size) 
    {
        if(!lowerBounds_) {
        lowerBounds_ = new double [size];
        }
        CoinCopyN(lb, size, lowerBounds_);
    }
    
    void setLowerBound(const int index, const double lb)
    {
        if(!lowerBounds_) {
        AbcModel * model = dynamic_cast<AbcModel*>(model_);
        const int numCols = model->getNumCols();    
        assert(numCols > index);
        lowerBounds_ = new double [numCols];
        }

        lowerBounds_[index] = lb;
    }
    
    double* upperBounds()
    {
        if(upperBounds_ == 0) {
        assert(model_);
        AbcModel* m = dynamic_cast<AbcModel*>(model_);
        const int num = m->getNumCols();
        const double* ub = m->getColUpper();
        upperBounds_ = new double [num];
        memcpy(upperBounds_, ub, sizeof(double)*num);
        }
        return upperBounds_;
    }
    
    void setUpperBounds(const double* ub, const int size) 
    {
        if(!upperBounds_) {
        upperBounds_ = new double [size];
        }
        CoinCopyN(ub, size, upperBounds_);
    }
    
    void setUpperBound(const int index, const double ub)
    {
        if (!upperBounds_) {
        AbcModel * model = dynamic_cast<AbcModel*>(model_);
        const int numCols = model->getNumCols();    
        assert(numCols > index);
        upperBounds_ = new double [numCols];
        }
        
        upperBounds_[index] = ub;
    }
    void setBranchedOn(int b) { branchedOn_ = b; }
    void setBranchedDir(int d) { branchedDir_ = d; }
    void setBranchedOnValue(double b) { branchedOnVal_ = b; }
    int getBranchedOn() const { return branchedOn_; }
    int getBranchedDir() const { return branchedDir_; }
    double getBranchedOnValue() const { return branchedOnVal_; }        
};

#endif