GAP_Instance.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 GAP_INSTANCE_INCLUDED
#define GAP_INSTANCE_INCLUDED

//===========================================================================//
#include "UtilMacros.h"

using namespace std;

//===========================================================================//
//===========================================================================//
class GAP_Instance {

private:
   int    m_nTasks;       //n (use j index)
   int    m_nMachines;    //m (use i index)
   int*   m_capacity;     //b[i = 1..m]
   int*   m_profit;       //p[i,j]
   int*   m_weight;       //w[i,j]

   bool      m_isProvenOptimal;
   double    m_bestKnownLB;
   double    m_bestKnownUB;


public:
   inline const int    getNTasks   ()  const {
      return m_nTasks;
   }
   inline const int    getNMachines()  const {
      return m_nMachines;
   }
   inline const int*   getCapacity ()  const {
      return m_capacity;
   }
   inline const int*   getProfit   ()  const {
      return m_profit;
   }
   inline const int*   getWeight   ()  const {
      return m_weight;
   }

public:
   void readInstance(string& filename);
   void readBestKnown(string& fileName,
                      string& instanceName);

   inline void initMembers() {
      m_nTasks    = 0;
      m_nMachines = 0;
      m_capacity  = NULL;
      m_profit    = NULL;
      m_weight    = NULL;
      m_isProvenOptimal =  false;
      m_bestKnownLB     = -1.e20;
      m_bestKnownUB     =  1.e20;
   }

   inline const int getIndexIJ(const int i,
                               const int j) const {
      return (i * m_nTasks) + j;
   }

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

   inline const double getBestKnownLB() const {
      return m_bestKnownLB;
   }
   inline const double getBestKnownUB() const {
      return m_bestKnownUB;
   }

public:
   GAP_Instance() {
      initMembers();
   };

   GAP_Instance(string& fileName) {
      initMembers();
      readInstance(fileName);
   }

   ~GAP_Instance() {
      UTIL_DELARR(m_capacity);
      UTIL_DELARR(m_profit);
      UTIL_DELARR(m_weight);
   };
};

#endif