OsiData.hpp

Go to the documentation of this file.

// Name:     OsiData.hpp
// Author:   Francois Margot
//           Tepper School of Business
//           Carnegie Mellon University, Pittsburgh, PA 15213
//           email: fmargot@andrew.cmu.edu
// Date:     12/2/06
//-----------------------------------------------------------------------------
// Copyright (C) 2006, Francois Margot and others.  All Rights Reserved.

#ifndef OsiData_H
#define OsiData_H

#include "CoinPackedMatrix.hpp"

class OsiData {

public:


   virtual void setInfinity(const double givenInfinity){
      infinity = givenInfinity;
   }
   
   inline double getInfinity() const {return infinity;};

   virtual void setNrow(const int givenNrow){
      nrow = givenNrow;
   }
   
   inline int getNrow() const {return nrow;};

   virtual void setNcol(const int givenNcol){
      ncol = givenNcol;
   }

   inline int getNcol() const {return ncol;};

   virtual void setMatrixByCol(const CoinPackedMatrix *givenMatrixByCol){
        matrixByCol = givenMatrixByCol;
   }

   inline const CoinPackedMatrix *getMatrixByCol() const {return matrixByCol;};

   virtual void setMatrixByRow(const CoinPackedMatrix *givenMatrixByRow){
      matrixByRow = givenMatrixByRow;
   }

   inline const CoinPackedMatrix *getMatrixByRow() const {return matrixByRow;};

   virtual void setObj(const double *givenObj){
      obj = givenObj;
   }

   inline const double *getObj() const {return obj;};

   virtual void setColLower(const double *givenColLower){
      colLower = givenColLower;
   }

   inline const double *getColLower() const {return colLower;};

   virtual void setColUpper(const double *givenColUpper){
      colUpper = givenColUpper;
   }
   
   inline const double *getColUpper() const {return colUpper;};

   virtual void setRowLower(const double *givenRowLower){
      rowLower = givenRowLower;
   }
   
   inline const double *getRowLower() const {return rowLower;};

   virtual void setRowUpper(const double *givenRowUpper){
      rowUpper = givenRowUpper;
   }

   inline const double *getRowUpper() const {return rowUpper;};

   //virtual void setRowRhs(const double *givenRowRhs);
   inline const double *getRowRhs() const {return rowRhs;};
   inline const double *getRowRange() const {return rowRange;};
   inline const char *getRowSense() const {return rowSense;};

   //virtual void setRowActivity(const double *givenRowActivity);
   inline const double *getRowActivity() const {return rowActivity;};

   virtual void setColType(const char *givenColType){
      colType = givenColType;
   }

   inline const char *getColType() const {return colType;};

   virtual void setPrimalSol(const double * givenPrimalSol){
      primalSol = givenPrimalSol;
   }

   inline const double *getPrimalSol() const {return primalSol;};

   void initializeOtherData(){
      CoinAssert(matrixByRow);
      CoinAssert(primalSol);
      
      rowRhs      = new double[nrow];
      rowRange    = new double[nrow];
      rowSense    = new char[nrow];
      rowActivity = new double[nrow];
      
      int    r;
      for(r = 0; r < nrow; r++){
         convertBoundToSense(rowLower[r], rowUpper[r], 
                             rowSense[r], rowRhs[r], rowRange[r]);
      }
      matrixByRow->times(primalSol, rowActivity);
   }

   inline void convertBoundToSense(const double   lower, 
                                   const double   upper,
                                   char         & sense, 
                                   double       & right,
                                   double       & range) const
   {
      double inf = getInfinity();
      range = 0.0;
      if (lower > -inf) {
         if (upper < inf) {
            right = upper;
            if (upper==lower) {
               sense = 'E';
            } else {
               sense = 'R';
               range = upper - lower;
            }
         } else {
            sense = 'G';
            right = lower;
         }
      } else {
         if (upper < inf) {
            sense = 'L';
            right = upper;
         } else {
            sense = 'N';
            right = 0.0;
         }
      }
   }

   OsiData(const double givenInfinity = DBL_MAX,
           const int &givenNrow = 0, 
           const int &givenNcol = 0,
           const CoinPackedMatrix * givenMatrixByCol = NULL,
           const CoinPackedMatrix * givenMatrixByRow = NULL,
           const double * givenObj = NULL,
           const double * givenColLower = NULL, 
           const double * givenColUpper = NULL,   
           const double * givenRowLower = NULL, 
           const double * givenRowUpper = NULL,
           const char   * givenColType = NULL,
           const double * givenPrimalSol = NULL) :
      infinity(givenInfinity),
      nrow(givenNrow),
      ncol(givenNcol),
      matrixByCol(givenMatrixByCol),
      matrixByRow(givenMatrixByRow),
      obj(givenObj),
      colLower(givenColLower),
      colUpper(givenColUpper),
      rowLower(givenRowLower),
      rowUpper(givenRowUpper),
      colType(givenColType),
      primalSol(givenPrimalSol) {}
   
   
   virtual ~OsiData(){
      if(rowRhs)
         delete [] rowRhs;
      if(rowRange)
         delete [] rowRange;
      if(rowSense)
         delete [] rowSense;
      if(rowActivity)
         delete [] rowActivity;
   }

protected:

   // Private member data


   // Definition of infinity
   double infinity;

   // Number of constraints
   int nrow;

   // Number of variables.
   int ncol;

   // Pointer on matrix of coefficients (ordered by columns).
   CoinPackedMatrix const *matrixByCol;

   // Pointer on matrix of coefficients (ordered by rows).
   CoinPackedMatrix const *matrixByRow;

   // Pointer on vector of objective coefficients. 
   const double *obj;

   // Pointer on vector of lower bounds on variables.
   const double *colLower; 

   // Pointer on vector of upper bounds for variables.
   const double *colUpper;   

   // Pointer on vector of lower bounds for constraints.
   const double *rowLower; 

   // Pointer on vector of upper bounds for constraints.
   const double *rowUpper;

   const char * colType;

   // Pointer on vector for current primal solution.
   const double * primalSol;

protected:
   
   // Vector of right hand sides for constraints.
   double * rowRhs;

   // Vector of ranges for constraints.
   double * rowRange;

   // Vector of row senses for constraints.
   char   * rowSense;

   // Vector of activity of constraints (i.e. coefficient matrix 
   // times primalSol).
   double * rowActivity;

   

};



#endif