OsiSolverInterface.hpp

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef OsiSolverInterface_H
#define OsiSolverInterface_H

#include <string>
#include <vector>

#include "CoinMessageHandler.hpp"
#include "CoinPackedVectorBase.hpp"

#include "OsiCollections.hpp"
#include "OsiSolverParameters.hpp"

class CoinPackedMatrix;
class CoinWarmStart;

class OsiCuts;
class OsiRowCut;
class OsiRowCutDebugger;

//#############################################################################

class OsiSolverInterface  {
   friend void OsiSolverInterfaceCommonUnitTest(
      const OsiSolverInterface* emptySi,
      const std::string & mpsDir,
      const std::string & netlibDir);
   friend void OsiSolverInterfaceMpsUnitTest(
      const std::vector<OsiSolverInterface*> & vecSiP,
      const std::string & mpsDir);

public:
  class ApplyCutsReturnCode {
    friend class OsiSolverInterface;
    friend class OsiOslSolverInterface;

  public:


      ApplyCutsReturnCode():
         intInconsistent_(0),
         extInconsistent_(0),
         infeasible_(0),
         ineffective_(0),
         applied_(0) {} 
      ApplyCutsReturnCode(const ApplyCutsReturnCode & rhs):
         intInconsistent_(rhs.intInconsistent_),
         extInconsistent_(rhs.extInconsistent_),
         infeasible_(rhs.infeasible_),
         ineffective_(rhs.ineffective_),
         applied_(rhs.applied_) {} 
      ApplyCutsReturnCode & operator=(const ApplyCutsReturnCode& rhs)
      { 
        if (this != &rhs) { 
          intInconsistent_ = rhs.intInconsistent_;
          extInconsistent_ = rhs.extInconsistent_;
          infeasible_      = rhs.infeasible_;
          ineffective_     = rhs.ineffective_;
          applied_         = rhs.applied_;
        }
        return *this;
      }
      ~ApplyCutsReturnCode(){}


      inline int getNumInconsistent(){return intInconsistent_;}
      inline int getNumInconsistentWrtIntegerModel(){return extInconsistent_;}
      inline int getNumInfeasible(){return infeasible_;}
      inline int getNumIneffective(){return ineffective_;}
      inline int getNumApplied(){return applied_;}

  private: 

      inline void incrementInternallyInconsistent(){intInconsistent_++;}
      inline void incrementExternallyInconsistent(){extInconsistent_++;}
      inline void incrementInfeasible(){infeasible_++;}
      inline void incrementIneffective(){ineffective_++;}
      inline void incrementApplied(){applied_++;}



      int intInconsistent_;
      int extInconsistent_;
      int infeasible_;
      int ineffective_;
      int applied_;
  };

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

public:


    virtual void initialSolve() = 0; 

    virtual void resolve() = 0;

    virtual void branchAndBound() = 0;

  //---------------------------------------------------------------------------
    // Set an integer parameter
    virtual bool setIntParam(OsiIntParam key, int value) {
      if (key == OsiLastIntParam) return (false) ;
      intParam_[key] = value;
      return true;
    }
    // Set an double parameter
    virtual bool setDblParam(OsiDblParam key, double value) {
      if (key == OsiLastDblParam) return (false) ;
      dblParam_[key] = value;
      return true;
    }
    // Set an string parameter
    virtual bool setStrParam(OsiStrParam key, const std::string & value) {
      if (key == OsiLastStrParam) return (false) ;
      strParam_[key] = value;
      return true;
    }
    // Set a hint parameter
    virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
                              OsiHintStrength strength=OsiHintTry,
                              void * otherInformation=NULL) {
      if (key==OsiLastHintParam)
        return false; 
      hintParam_[key] = yesNo;
      hintStrength_[key] = strength;
      if (strength == OsiForceDo)
        throw CoinError("OsiForceDo illegal",
                        "setHintParam", "OsiSolverInterface");
      return true;
    }
    // Get an integer parameter
    virtual bool getIntParam(OsiIntParam key, int& value) const {
      if (key == OsiLastIntParam) return (false) ;
      value = intParam_[key];
      return true;
    }
    // Get an double parameter
    virtual bool getDblParam(OsiDblParam key, double& value) const {
      if (key == OsiLastDblParam) return (false) ;
      value = dblParam_[key];
      return true;
    }
    // Get a string parameter
    virtual bool getStrParam(OsiStrParam key, std::string& value) const {
      if (key == OsiLastStrParam) return (false) ;
      value = strParam_[key];
      return true;
    }
    // get a hint parameter
    virtual bool getHintParam(OsiHintParam key, bool& yesNo,
                              OsiHintStrength& strength,
                              void *& otherInformation) const {
      if (key==OsiLastHintParam)
        return false; 
      yesNo = hintParam_[key];
      strength = hintStrength_[key];
      otherInformation=NULL;
      return true;
    }
    // get a hint parameter (less information)
    virtual bool getHintParam(OsiHintParam key, bool& yesNo,
                              OsiHintStrength& strength) const {
      if (key==OsiLastHintParam)
        return false; 
      yesNo = hintParam_[key];
      strength = hintStrength_[key];
      return true;
    }
    // get a hint parameter (even less information)
    virtual bool getHintParam(OsiHintParam key, bool& yesNo) const {
      if (key==OsiLastHintParam)
        return false; 
      yesNo = hintParam_[key];
      return true;
    }
    // copy all parameters in this section from one solver to another
    void copyParameters(OsiSolverInterface & rhs);

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


    virtual bool isAbandoned() const = 0;
    virtual bool isProvenOptimal() const = 0;
    virtual bool isProvenPrimalInfeasible() const = 0;
    virtual bool isProvenDualInfeasible() const = 0;
    virtual bool isPrimalObjectiveLimitReached() const = 0;
    virtual bool isDualObjectiveLimitReached() const = 0;
    virtual bool isIterationLimitReached() const = 0;

  //---------------------------------------------------------------------------
    virtual CoinWarmStart *getEmptyWarmStart () const = 0 ;

    virtual CoinWarmStart* getWarmStart() const = 0;

    virtual bool setWarmStart(const CoinWarmStart* warmstart) = 0;

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

    virtual void markHotStart();
    virtual void solveFromHotStart();
    virtual void unmarkHotStart();

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

      virtual int getNumCols() const = 0;
  
      virtual int getNumRows() const = 0;
  
      virtual int getNumElements() const = 0;
  
      virtual const double * getColLower() const = 0;
  
      virtual const double * getColUpper() const = 0;
  
      virtual const char * getRowSense() const = 0;
  
      virtual const double * getRightHandSide() const = 0;
  
      virtual const double * getRowRange() const = 0;
  
      virtual const double * getRowLower() const = 0;
  
      virtual const double * getRowUpper() const = 0;
  
      virtual const double * getObjCoefficients() const = 0;
  
      virtual double getObjSense() const = 0;
  
      virtual bool isContinuous(int colIndex) const = 0;
  
      virtual bool isBinary(int colIndex) const;
  
      virtual bool isInteger(int colIndex) const;
  
      virtual bool isIntegerNonBinary(int colIndex) const;
  
      virtual bool isFreeBinary(int colIndex) const; 
    
      virtual const CoinPackedMatrix * getMatrixByRow() const = 0;
  
      virtual const CoinPackedMatrix * getMatrixByCol() const = 0;
  
      virtual double getInfinity() const = 0;
    

      virtual const double * getColSolution() const = 0;
  
      virtual const double * getRowPrice() const = 0;
  
      virtual const double * getReducedCost() const = 0;
  
      virtual const double * getRowActivity() const = 0;
  
      virtual double getObjValue() const = 0;

      virtual int getIterationCount() const = 0;
  
      virtual std::vector<double*> getDualRays(int maxNumRays) const = 0;
      virtual std::vector<double*> getPrimalRays(int maxNumRays) const = 0;
  
      virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
        const;

    //-------------------------------------------------------------------------
      virtual void setObjCoeff( int elementIndex, double elementValue ) = 0;

      virtual void setObjCoeffSet(const int* indexFirst,
                                  const int* indexLast,
                                  const double* coeffList);

      virtual void setColLower( int elementIndex, double elementValue ) = 0;
      
      virtual void setColUpper( int elementIndex, double elementValue ) = 0;
      
      virtual void setColBounds( int elementIndex,
                                 double lower, double upper ) {
         setColLower(elementIndex, lower);
         setColUpper(elementIndex, upper);
      }
    
      virtual void setColSetBounds(const int* indexFirst,
                                   const int* indexLast,
                                   const double* boundList);
      
      virtual void setRowLower( int elementIndex, double elementValue ) = 0;
      
      virtual void setRowUpper( int elementIndex, double elementValue ) = 0;
    
      virtual void setRowBounds( int elementIndex,
                                 double lower, double upper ) {
         setRowLower(elementIndex, lower);
         setRowUpper(elementIndex, upper);
      }
    
      virtual void setRowType(int index, char sense, double rightHandSide,
                              double range) = 0;
    
      virtual void setRowSetBounds(const int* indexFirst,
                                   const int* indexLast,
                                   const double* boundList);
    
      virtual void setRowSetTypes(const int* indexFirst,
                                  const int* indexLast,
                                  const char* senseList,
                                  const double* rhsList,
                                  const double* rangeList);
    
    virtual void setObjSense(double s) = 0;
    
    virtual void setColSolution(const double *colsol) = 0;

   virtual void setRowPrice(const double * rowprice) = 0;


    //-------------------------------------------------------------------------
      virtual void setContinuous(int index) = 0;
      virtual void setInteger(int index) = 0;
      virtual void setContinuous(const int* indices, int len);
      virtual void setInteger(const int* indices, int len);
    //-------------------------------------------------------------------------
    
    //-------------------------------------------------------------------------
      virtual void addCol(const CoinPackedVectorBase& vec,
                          const double collb, const double colub,   
                          const double obj) = 0;
      virtual void addCols(const int numcols,
                           const CoinPackedVectorBase * const * cols,
                           const double* collb, const double* colub,   
                           const double* obj);
#if 0

      virtual void addCols(const CoinPackedMatrix& matrix,
                           const double* collb, const double* colub,   
                           const double* obj);
#endif

      virtual void deleteCols(const int num, const int * colIndices) = 0;
    
      virtual void addRow(const CoinPackedVectorBase& vec,
                          const double rowlb, const double rowub) = 0;
      virtual void addRow(const CoinPackedVectorBase& vec,
                          const char rowsen, const double rowrhs,   
                          const double rowrng) = 0;
      virtual void addRows(const int numrows,
                           const CoinPackedVectorBase * const * rows,
                           const double* rowlb, const double* rowub);
      virtual void addRows(const int numrows,
                           const CoinPackedVectorBase * const * rows,
                           const char* rowsen, const double* rowrhs,   
                           const double* rowrng);
#if 0

      virtual void addRows(const CoinPackedMatrix& matrix,
                           const double* rowlb, const double* rowub);
      virtual void addRows(const CoinPackedMatrix& matrix,
                           const char* rowsen, const double* rowrhs,   
                           const double* rowrng);
#endif

      virtual void deleteRows(const int num, const int * rowIndices) = 0;
    
      //-----------------------------------------------------------------------
      virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
                                            double effectivenessLb = 0.0);
      virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);

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

    virtual void loadProblem(const CoinPackedMatrix& matrix,
                             const double* collb, const double* colub,   
                             const double* obj,
                             const double* rowlb, const double* rowub) = 0;
                            
    virtual void assignProblem(CoinPackedMatrix*& matrix,
                               double*& collb, double*& colub, double*& obj,
                               double*& rowlb, double*& rowub) = 0;

    virtual void loadProblem(const CoinPackedMatrix& matrix,
                             const double* collb, const double* colub,
                             const double* obj,
                             const char* rowsen, const double* rowrhs,   
                             const double* rowrng) = 0;

    virtual void assignProblem(CoinPackedMatrix*& matrix,
                               double*& collb, double*& colub, double*& obj,
                               char*& rowsen, double*& rowrhs,
                               double*& rowrng) = 0;

    virtual void loadProblem(const int numcols, const int numrows,
                             const int* start, const int* index,
                             const double* value,
                             const double* collb, const double* colub,   
                             const double* obj,
                             const double* rowlb, const double* rowub) = 0;

    virtual void loadProblem(const int numcols, const int numrows,
                             const int* start, const int* index,
                             const double* value,
                             const double* collb, const double* colub,   
                             const double* obj,
                             const char* rowsen, const double* rowrhs,   
                             const double* rowrng) = 0;

    virtual int readMps(const char *filename,
                         const char *extension = "mps") ;

    virtual void writeMps(const char *filename,
                          const char *extension = "mps",
                          double objSense=0.0) const = 0;

    int writeMpsNative(const char *filename, 
                  const char ** rowNames, const char ** columnNames,
                  int formatType=0,int numberAcross=2,
                 double objSense=0.0) const ;

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

    void setApplicationData (void * appData);

    void * getApplicationData() const;
  //---------------------------------------------------------------------------

  void passInMessageHandler(CoinMessageHandler * handler);
  void newLanguage(CoinMessages::Language language);
  void setLanguage(CoinMessages::Language language)
  {newLanguage(language);};
  CoinMessageHandler * messageHandler() const
  {return handler_;};
  CoinMessages messages() 
  {return messages_;};
  CoinMessages * messagesPointer() 
  {return &messages_;};
  //---------------------------------------------------------------------------

    virtual void activateRowCutDebugger (const char * modelName);

    const OsiRowCutDebugger * getRowCutDebugger() const;

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



    OsiSolverInterface(); 
    
    virtual OsiSolverInterface * clone(bool copyData = true) const = 0;
  
    OsiSolverInterface(const OsiSolverInterface &);
  
    OsiSolverInterface & operator=(const OsiSolverInterface& rhs);
  
    virtual ~OsiSolverInterface ();

    virtual void reset();

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

protected:


    virtual void applyRowCut( const OsiRowCut & rc ) = 0;

    virtual void applyColCut( const OsiColCut & cc ) = 0;

    inline void
    convertBoundToSense(const double lower, const double upper,
                        char& sense, double& right, double& range) const;
    inline void
    convertSenseToBound(const char sense, const double right,
                        const double range,
                        double& lower, double& upper) const;
    template <class T> inline T
    forceIntoRange(const T value, const T lower, const T upper) const {
      return value < lower ? lower : (value > upper ? upper : value);
    }
    void setInitialData();



    OsiRowCutDebugger * rowCutDebugger_;
  
  //---------------------------------------------------------------------------

private:


    void * appData_;
    int intParam_[OsiLastIntParam];
    double dblParam_[OsiLastDblParam];
    std::string strParam_[OsiLastStrParam];
    bool hintParam_[OsiLastHintParam];
    OsiHintStrength hintStrength_[OsiLastHintParam];
    CoinWarmStart* ws_;
  // Why not just make useful stuff protected?
protected:
  CoinMessageHandler * handler_;
  bool defaultHandler_;
  CoinMessages messages_;
};

//#############################################################################
void
OsiSolverInterfaceCommonUnitTest(
   const OsiSolverInterface* emptySi,
   const std::string & mpsDir,
   const std::string & netlibDir);

//#############################################################################
void
OsiSolverInterfaceMpsUnitTest(
   const std::vector<OsiSolverInterface*> & vecSiP,
   const std::string & mpsDir);

//#############################################################################
inline void
OsiSolverInterface::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;
    }
  }
}

//-----------------------------------------------------------------------------
inline void
OsiSolverInterface::convertSenseToBound(const char sense, const double right,
                                        const double range,
                                        double& lower, double& upper) const
{
  double inf=getInfinity();
  switch (sense) {
  case 'E':
    lower = upper = right;
    break;
  case 'L':
    lower = -inf;
    upper = right;
    break;
  case 'G':
    lower = right;
    upper = inf;
    break;
  case 'R':
    lower = right - range;
    upper = right;
    break;
  case 'N':
    lower = -inf;
    upper = inf;
    break;
  }
}

#endif

---