MAD_DecompApp.h

Go to the documentation of this file.

//===========================================================================//
// This file is part of the Decomp Solver Framework.                         //
//                                                                           //
// Decomp is distributed under the Common 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, and Ted Ralphs//
// All Rights Reserved.                                                      //
//===========================================================================//

#ifndef MAD_DECOMPAPP_INCLUDED
#define MAD_DECOMPAPP_INCLUDED

#define __MAD_USE_QUALEX__
#define __MAD_USE_CLIQUER__

// --------------------------------------------------------------------- //
#include "DecompApp.h"
#include "MAD_MemPool.h"
#include "MAD_DecompParam.h"
#include "MAD_DecompDebug.h"
#include "CoinLpIO.hpp"
// --------------------------------------------------------------------- //

#ifdef __MAD_USE_CLIQUER__
#include "MAD_Cliquer.h"
#define cliquer_t MAD_Cliquer
#else
#define cliquer_t void
#endif

#ifdef __MAD_USE_QUALEX__
#include "MAD_Qualex.h"
#define MAD_Qualex MAD_Qualex
#else
#define MAX_Qualex void
#endif

// --------------------------------------------------------------------- //
typedef enum MAD_HeurSortDir{
   INCREASING,
   DECREASING
};

// --------------------------------------------------------------------- //
typedef struct GreedyPoint GreedyPoint;
struct GreedyPoint {
   double * solution;
   double   solValueOrigCost;    
   double   solValueRedCost; 
};


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

// --------------------------------------------------------------------- //
class MAD_DecompApp : public DecompApp {
 private:
   const string m_classTag;

 private:
   CoinLpIO  m_instance;
   int       m_nOrigRows;
   int       m_beta;
   int       m_kappa;

   cliquer_t * m_cliquer;

   MAD_Qualex * m_qualex;

   //THINK about data structures! if have cliquer around vs qualex
   //or just use generic boost? in the case that we have neither?
   graph_t   * m_conflictGraph;

   MAD_MemPool m_auxMemPool;

 
 protected:
   MAD_DecompParam m_appParam;  
   
 public:
   enum ModelType {
      MODEL_CLIQUE
   };
   
 public:
   /* @name Inherited (from pure virtual) methods. */

   //TODO: model object? vs objCoeff?
   void APPcreateModel(double                        *& objCoeff,
                       map<int, DecompConstraintSet*> & modelCore,
                       map<int, vector<DecompConstraintSet* > > & modelRelax);

 public:
   /* @name Inherited (from virtual) methods. */

   //TOOD: too messy?
   DecompStatus APPsolveRelaxed(const int             whichModel,
                const double        * redCostX,
                const double        * origCost,
                const double          alpha,
                const int             n_origCols,
                const bool            checkRC,
                const bool            checkDup,
                bool                & isExact,
                OsiSolverInterface  * m_subprobSI,
                list<DecompVar*>    & vars);
   
   int APPheuristics(const double            * xhat,
             const double            * origCost,
             vector<DecompSolution*> & xhatIPFeas);   

    int generateInitVars(DecompVarList & initVars);

   void printOriginalColumn(const int   index, 
                            ostream   * os = &cout) const;
   
   void printOriginalSolution(const int      n_cols, 
                              const double * solution, 
                              ostream      * os) const;

 public:
   inline const int xIndex(const int i, 
                           const int b) const{ 
      return i * m_beta + b;
   }

   inline pair<int,int> xIndexInv(const int index) const{      
     return make_pair(index / m_beta, index % m_beta);
   }

   int isOrtho(const int    * rowInd1,
               const int    * rowInd2,
               const int      rowLen1,
               const int      rowLen2);

   void initializeApp(UtilParameters & utilParam);

   int heuristicGreedy(vector<GreedyPoint>     & greedyPoints,
               const MAD_HeurSortDir     sortDir,
               const double            * sortValues,
               const double            * origCost,
               const double            * redCost = NULL);
   int heuristicGreedy(const MAD_HeurSortDir     sortDir,
               const double            * sortValues,
               const double            * origCost,
               vector<DecompSolution*> & solVec);
      



   void printRowMarks(const int * rowInd,
                      const int   rowLen) const;


   inline const int getNOrigRows() const { return m_nOrigRows; }
   inline const int getBeta()      const { return m_beta;      }
   inline const int getKappa()     const { return m_kappa;     }


   
 private:
   MAD_DecompApp(const MAD_DecompApp &);
   MAD_DecompApp & operator=(const MAD_DecompApp &);

 public:
   MAD_DecompApp(UtilParameters & utilParam) : 
      DecompApp(utilParam), 
      m_classTag("MAD-APP"),
      m_beta(0),
      m_kappa(0),
      m_cliquer(0),
      m_conflictGraph(0),
      m_auxMemPool(),
//      m_bestKnownLB(-1.0e20),
//      m_bestKnownUB( 1.0e20),
      m_appParam()
      {
         initializeApp(utilParam);
      }
   
   virtual ~MAD_DecompApp() {  
      UTIL_DELPTR(m_cliquer);
      UTIL_DELPTR(m_qualex);
      graph_free(m_conflictGraph);
   };
};

#endif