DecompAlgoPC.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 DecompAlgoPC_h_
#define DecompAlgoPC_h_

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

//===========================================================================//
#include "DecompAlgo.h"

//===========================================================================//
class DecompAlgoPC : public DecompAlgo {

private:

   //----------------------------------------------------------------------//
   //----------------------------------------------------------------------//
   std::string m_classTag;

   std::vector<double> m_dual;

   std::vector<double> m_dualRM;

   std::vector<double> m_dualST;

   //-----------------------------------------------------------------------//
   //-----------------------------------------------------------------------//
   virtual void createMasterProblem(DecompVarList& initVars) {
      DecompAlgo::createMasterProblem(initVars);
   }
   virtual int generateVars(DecompVarList&     newVars,
                double&            mostNegReducedCost) {
      return DecompAlgo::generateVars(newVars, mostNegReducedCost);
   }
   virtual void phaseInit(DecompPhase& phase);

   virtual const double* getMasterDualSolution() const {
      //---
      //--- return the duals to be used in pricing step
      //---
      if (m_param.DualStab) {
         return &m_dualST[0];
      } else {
         return &m_dualSolution[0];
      }
   }

   virtual void adjustMasterDualSolution();



   virtual void setObjBound(const double thisBound,
                            const double thisBoundUB) {
      UtilPrintFuncBegin(m_osLog, m_classTag,
                         "setObjBound()", m_param.LogDebugLevel, 2);

      if (m_param.DualStab) {
         if (thisBound > (m_nodeStats.objBest.first + DecompEpsilon)) {
            //(*m_osLog) << "Bound improved " << m_nodeStats.objBest.first
            //       << " to " << thisBound << " , update duals" << endl;
            copy(m_dualST.begin(), m_dualST.end(), m_dual.begin());
         }
      }

      DecompAlgo::setObjBound(thisBound, thisBoundUB);
      UtilPrintFuncEnd(m_osLog, m_classTag,
                       "setObjBound()", m_param.LogDebugLevel, 2);
   }

   virtual inline void setObjBoundIP(const double thisBound) {
      DecompAlgo::setObjBoundIP(thisBound);
   }

   //-----------------------------------------------------------------------//
   //-----------------------------------------------------------------------//
   //TODO
   void addCutsToPool(const double*    x,
                      DecompCutList& newCuts,
                      int&            n_newCuts);

   //TODO
   void phaseDone();
   int  addCutsFromPool();
   void solveMasterAsMIP();
   void solveMasterAsMIPSym(DecompSolverResult* result);
   void solveMasterAsMIPCbc(DecompSolverResult* result);
   void solveMasterAsMIPCpx(DecompSolverResult* result);
   void solveMasterAsMIPGrb(DecompSolverResult* result);
   int  adjustColumnsEffCnt();
   int  compressColumns    ();

   //-----------------------------------------------------------------------//
   //-----------------------------------------------------------------------//
public:

   std::vector<double>& getDualBest() {
      return m_dual;
   }
   std::vector<double>& getDualRMP() {
      return m_dualRM;
   }


   DecompAlgoPC(DecompApp*       app,
                UtilParameters& utilParam,
                bool             doSetup    = true,
        const DecompAlgoType   algo = PRICE_AND_CUT) :
      DecompAlgo(algo, app, utilParam),
      m_classTag("D-ALGOPC") {
      //---
      //--- do any parameter overrides of the defaults here
      //---    by default turn off gomory cuts for PC
      //---
      m_param.CutCglGomory = 0;
   }

   ~DecompAlgoPC() {}
};

#endif