DecompStats.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 DecompStats_h_
#define DecompStats_h_

//===========================================================================//
#include "Decomp.h"
#include "UtilTimer.h"
//===========================================================================//

//===========================================================================//
class DecompObjBound {
public:
   int phase;
   int cutPass;
   int pricePass;
   double timeStamp;
   double thisBound;
   double thisBoundUB;
   double bestBound;
   double thisBoundIP;
   double bestBoundIP;

   bool operator<(const DecompObjBound& objBound) const {
      if (timeStamp < objBound.timeStamp) {
         return true;
      } else {
         return false;
      }
   }

public:
   DecompObjBound(double infinity) :
      phase      (0),
      cutPass    (0),
      pricePass  (0),
      timeStamp  (0.0),
      thisBound  (-infinity),
      thisBoundUB( infinity),
      bestBound  (-infinity),
      thisBoundIP( infinity),
      bestBoundIP( infinity) {
   }

};

//===========================================================================//
class DecompNodeStats {
public:

   //---
   //--- Storage for the bound history for a node.
   //---    NOTE: we always assume a minimization problem
   //---

   std::vector< DecompObjBound > objHistoryBound;

   std::pair<double, double> objBest;

   int    nodeIndex;

   int    cutsThisRound;

   int    varsThisRound;

   int    cutsThisCall;

   int    varsThisCall;

   int    cutCallsTotal;

   int    priceCallsTotal;

   int    cutCallsRound;

   int    priceCallsRound;

   double m_infinity;

public:
   void init() {
      objHistoryBound.clear();
      objBest.first   = -m_infinity;
      objBest.second  =  m_infinity;
      nodeIndex       =  0;
      cutsThisRound   =  0;
      varsThisRound   =  0;
      cutsThisCall    =  0;
      varsThisCall    =  0;
      cutCallsTotal   =  0;
      priceCallsTotal =  0;
      cutCallsRound   =  0;
      priceCallsRound =  0;
   }

public:
   void printObjHistoryBound  (std::ostream* os = &std::cout) const;
   inline void resetCutRound() {
      cutCallsRound = 0;
      cutsThisRound = 0;
   }
   inline void resetPriceRound() {
      priceCallsRound = 0;
      varsThisRound   = 0;
   }
   inline void resetBestLB() {
      objBest.first = -m_infinity;
   }
   inline DecompObjBound* getLastBound() {
      int nHistorySize = static_cast<int>(objHistoryBound.size());

      if (nHistorySize > 0) {
         return &(objHistoryBound[nHistorySize - 1]);
      } else {
         return 0;
      }
   }
   inline double getLastBoundThis() {
      double           thisBound = -m_infinity;
      DecompObjBound* lastBound = getLastBound();

      if (lastBound) {
         thisBound = lastBound->thisBound;
      }

      return thisBound;
   }

public:
   DecompNodeStats() :
      objHistoryBound(),
      objBest        (),
      m_infinity     (COIN_DBL_MAX) {
      init();
   }
};


//===========================================================================//
class DecompStats {

public:
   UtilTimer timerOverall;
   UtilTimer timerDecomp;
   UtilTimer timerOther1;
   UtilTimer timerOther2;

public:
   double totalOverall;

   double totalDecomp;
   double totalSolveRelax;
   double totalSolveRelaxApp;
   double totalSolUpdate;
   double totalGenCuts;
   double totalGenCutsApp;
   double totalGenVars;
   double totalCompressCols;

   double maxDecomp;
   double maxSolveRelax;
   double maxSolveRelaxApp;
   double maxSolUpdate;
   double maxGenCuts;
   double maxGenVars;
   double maxCompressCols;

public:
   std::vector<double> thisDecomp;
   std::vector<double> thisSolveRelax;
   std::vector<double> thisSolveRelaxApp;
   std::vector<double> thisSolUpdate;
   std::vector<double> thisGenCuts;
   std::vector<double> thisGenCutsApp;
   std::vector<double> thisGenVars;
   std::vector<double> thisCompressCols;

public:
   void calculateStats();
   void printOverallStats (std::ostream* os = &std::cout); //ostream?
   void printDetailedStats(std::ostream* os = &std::cout); //ostream?

public:
   DecompStats() :

      totalOverall      (0.0),

      totalDecomp       (0.0),
      totalSolveRelax   (0.0),
      totalSolveRelaxApp(0.0),
      totalSolUpdate    (0.0),
      totalGenCuts      (0.0),
      totalGenCutsApp   (0.0),
      totalGenVars      (0.0),
      totalCompressCols (0.0),

      maxDecomp         (0.0),
      maxSolveRelax     (0.0),
      maxSolveRelaxApp  (0.0),
      maxSolUpdate      (0.0),
      maxGenCuts        (0.0),
      maxGenVars        (0.0),
      maxCompressCols   (0.0)

   {
   }

   ~DecompStats() {}

};
//===========================================================================//

#endif