DecompAlgoRC.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 DecompAlgoRC_h_
#define DecompAlgoRC_h_

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

//===========================================================================//
class DecompAlgoRC : public DecompAlgo {

   //----------------------------------------------------------------------//
   //----------------------------------------------------------------------//
private:
   const std::string m_classTag;

private:
   std::vector<double>   m_u;   //dual vector
   double*          m_rc;  //reduced cost

   double           m_UB;
   double           m_LB;

   int              m_cntSameLB;
   int              m_iter;
   double           m_step;
   bool             m_zeroSub;

   DecompVar        m_shatVar;
   //-----------------------------------------------------------------------//
   //-----------------------------------------------------------------------//
   void createMasterProblem(DecompVarList& initVars);

   //not pure
   void recomposeSolution(const double* solution,
                          double*        rsolution);


   //-----------------------------------------------------------------------//
   //-----------------------------------------------------------------------//
   DecompStatus solutionUpdate(const DecompPhase phase,
                               const int         maxInnerIter,
                               const int         maxOuterIter);
   int addCutsFromPool();
   int generateVars(DecompVarList&     newVars,
                    double&            mostNegReducedCost);
   bool updateObjBound(const double mostNegRC = -DecompBigNum);

   DecompPhase phaseInit();
   void phaseDone();


   //-----------------------------------------------------------------------//
   //-----------------------------------------------------------------------//
private:
   DecompAlgoRC(const DecompAlgoRC&);
   DecompAlgoRC& operator=(const DecompAlgoRC&);

public:
   DecompAlgoRC(DecompApp*             app,
                UtilParameters&        utilParam):
      DecompAlgo(RELAX_AND_CUT, app, utilParam),
      m_classTag("D-ALGORC"),
      m_u        (),
      m_rc       (NULL),
      m_UB       (m_infinity),
      m_LB       (-m_infinity),
      m_cntSameLB(0),
      m_iter     (0),
      m_step     (2.0), //(0, 2] param?
      m_zeroSub  (false),
      m_shatVar  ()
   {
   }

   ~DecompAlgoRC() {
      UTIL_DELARR(m_rc);
   }
public:
   bool isDone();
   //name - change to getDual?
   const double* getRowPrice() {
      return &m_u[0];
   }
   //user needs to do?
   //STOP
   void setInitObjUB(const double objUB) {
      m_UB = objUB;
   }


};
#endif