AlpsDecompNodeDesc.h

Go to the documentation of this file.

//===========================================================================//
// This file is part of the DIP Solver Framework.                            //
//                                                                           //
// DIP is distributed under the Eclipse Public License as part of the        //
// COIN-OR repository (http://www.coin-or.org).                              //
//                                                                           //
// Authors: Matthew Galati, SAS Institute Inc. (matthew.galati@sas.com)      //
//          Ted Ralphs, Lehigh University (ted@lehigh.edu)                   //
//          Jiadong Wang, Lehigh University (jiw408@lehigh.edu)              //
//                                                                           //
// Copyright (C) 2002-2019, Lehigh University, Matthew Galati, Ted Ralphs    //
// All Rights Reserved.                                                      //
//===========================================================================//

//===========================================================================//
#ifndef AlpsDecompNodeDesc_h_
#define AlpsDecompNodeDesc_h_

//===========================================================================//
#include "AlpsEncoded.h"
#include "AlpsNodeDesc.h"
#include "AlpsDecompModel.h"
#include "UtilMacrosAlps.h"

//===========================================================================//
class CoinWarmStartBasis;

//===========================================================================//
//===========================================================================//

//===========================================================================//
class AlpsDecompNodeDesc : public AlpsNodeDesc {

private:

   //----------------------------------------------------------------------//
   //----------------------------------------------------------------------//

   std::string m_classTag;

public:
   double* lowerBounds_;
   double* upperBounds_;
   int numberCols_;
   int branchedDir_;
   std::vector< std::pair<int, double> > branched_;

   //THINK: different derivations for different algos? need?
   CoinWarmStartBasis* basis_;

public:

   AlpsDecompNodeDesc() :
      AlpsNodeDesc(),
      branchedDir_(0),
      basis_(NULL) {
   }

   AlpsDecompNodeDesc(AlpsModel* m)
      :
      AlpsNodeDesc(m),
      branchedDir_(0),
      basis_(NULL) {
   }

   AlpsDecompNodeDesc(AlpsDecompModel* m,
                      const double*     lb,
                      const double*     ub)
      :
      AlpsNodeDesc(m),
      branchedDir_(0),
      basis_(NULL) {
      numberCols_ = m->getNumCoreCols();
      assert(numberCols_);
      lowerBounds_ = new double [numberCols_];
      upperBounds_ = new double [numberCols_];
      memcpy(lowerBounds_, lb, sizeof(double)*numberCols_);
      memcpy(upperBounds_, ub, sizeof(double)*numberCols_);
   }

   virtual ~AlpsDecompNodeDesc() {
      if (lowerBounds_ != 0) {
         delete [] lowerBounds_;
         lowerBounds_ = 0;
      }

      if (upperBounds_ != 0) {
         delete [] upperBounds_;
         upperBounds_ = 0;
      }

      delete basis_;
   }

   void setBasis(CoinWarmStartBasis*& ws) {
      if (basis_) {
         delete basis_;
      }

      basis_ = ws;
      ws = NULL;
   }

   CoinWarmStartBasis* getBasis() const {
      return basis_;
   }

   void setBranchedDir(int d) {
      branchedDir_ = d;
   }

   int getBranchedDir() const {
      return branchedDir_;
   }

   void setBranched(std::vector< std::pair<int, double> > b) {
      branched_ = b;
   }

   std::vector< std::pair<int, double> > getBranched() const {
      return branched_;
   }

protected:

   //---
   //--- helper functions for encode/decode
   //---

   AlpsReturnStatus encodeAlpsDecomp(AlpsEncoded* encoded) const {
      AlpsReturnStatus status = AlpsReturnStatusOk;
      encoded->writeRep(branchedDir_);
      // Basis
      int ava = 0;

      if (basis_) {
         ava = 1;
         encoded->writeRep(ava);
         //should this be a util func or blis func?
         //seems pretty standard, alps/coin util type stuff
         UtilAlpsEncodeWarmStart(encoded, basis_);
      } else {
         encoded->writeRep(ava);
      }

      return status;
   }

   AlpsReturnStatus decodeAlpsDecomp(AlpsEncoded& encoded) {
      AlpsReturnStatus status = AlpsReturnStatusOk;
      encoded.readRep(branchedDir_);
      // Basis
      int ava;
      encoded.readRep(ava);

      if (ava == 1) {
         basis_ = UtilAlpsDecodeWarmStart(encoded, &status);
      } else {
         basis_ = NULL;
      }

      return status;
   }

public:

   //---
   //--- pure virtual functions from AlpsNodeDesc or AlpsNodeDesc
   //---

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

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

};
#endif