OsiSolverInterface.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef OsiSolverInterface_H
#define OsiSolverInterface_H

#include <cstdlib>
#include <string>
#include <vector>

#include "CoinTypes.hpp"
#include "CoinMessageHandler.hpp"
#include "CoinPackedVectorBase.hpp"
#include "CoinPackedMatrix.hpp"
#include "CoinWarmStart.hpp"
#include "CoinFinite.hpp"
#include "CoinError.hpp"

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

class CoinSnapshot;
class CoinLpIO;
class CoinMpsIO;

class OsiCuts;
class OsiAuxInfo;
class OsiRowCut;
class OsiRowCutDebugger;
class CoinSet;
class CoinBuild;
class CoinModel;
class OsiSolverBranch;
class OsiSolverResult;
class OsiObject;


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

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 OsiClpSolverInterface;
    friend class OsiGrbSolverInterface;

  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() const
      {return intInconsistent_;}
      inline int getNumInconsistentWrtIntegerModel() const
      {return extInconsistent_;}
      inline int getNumInfeasible() const
      {return infeasible_;}
      inline int getNumIneffective() const
      {return ineffective_;}
      inline int getNumApplied() const
      {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_;
  };

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


    virtual void initialSolve() = 0; 

    virtual void resolve() = 0;

    virtual void branchAndBound() = 0;

#ifdef CBC_NEXT_VERSION
    /*
      Would it make sense to collect all of these routines in a `MIP Helper'
      section? It'd make it easier for users and implementors to find them.
    */
    virtual int solveBranches(int depth,const OsiSolverBranch * branch,
                              OsiSolverResult * result,
                              int & numberSolves, int & numberIterations,
                              bool forceBranch=false);
#endif


  //---------------------------------------------------------------------------
    virtual bool setIntParam(OsiIntParam key, int value) {
      if (key == OsiLastIntParam) return (false) ;
      intParam_[key] = value;
      return true;
    }
    virtual bool setDblParam(OsiDblParam key, double value) {
      if (key == OsiLastDblParam) return (false) ;
      dblParam_[key] = value;
      return true;
    }
    virtual bool setStrParam(OsiStrParam key, const std::string & value) {
      if (key == OsiLastStrParam) return (false) ;
      strParam_[key] = value;
      return true;
    }
    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;
    }
    virtual bool getIntParam(OsiIntParam key, int& value) const {
      if (key == OsiLastIntParam) return (false) ;
      value = intParam_[key];
      return true;
    }
    virtual bool getDblParam(OsiDblParam key, double& value) const {
      if (key == OsiLastDblParam) return (false) ;
      value = dblParam_[key];
      return true;
    }
    virtual bool getStrParam(OsiStrParam key, std::string& value) const {
      if (key == OsiLastStrParam) return (false) ;
      value = strParam_[key];
      return true;
    }
    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;
    }
    virtual bool getHintParam(OsiHintParam key, bool& yesNo,
                              OsiHintStrength& strength) const {
      if (key==OsiLastHintParam)
        return false; 
      yesNo = hintParam_[key];
      strength = hintStrength_[key];
      return true;
    }
    virtual bool getHintParam(OsiHintParam key, bool& yesNo) const {
      if (key==OsiLastHintParam)
        return false; 
      yesNo = hintParam_[key];
      return true;
    }
    void copyParameters(OsiSolverInterface & rhs);

    inline double getIntegerTolerance() const
    { return dblParam_[OsiPrimalTolerance];}

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

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

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

    virtual CoinWarmStart* getWarmStart() const = 0;
    virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;

    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 int getNumIntegers() const ;

    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; 

    inline const char *columnType(bool refresh=false) const
    { return getColType(refresh); }

    virtual const char * getColType(bool refresh=false) const;
  
    virtual const CoinPackedMatrix * getMatrixByRow() const = 0;

    virtual const CoinPackedMatrix * getMatrixByCol() const = 0;

    virtual CoinPackedMatrix * getMutableMatrixByRow() const {return NULL;}

    virtual CoinPackedMatrix * getMutableMatrixByCol() const {return NULL;}

    virtual double getInfinity() const = 0;
    
    virtual const double * getColSolution() const = 0;

    virtual const double * getStrictColSolution();

    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,
                                             bool fullRay = false) 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 setObjective(const double * array);

    virtual void setObjSense(double s) = 0;
  

    virtual void setColLower( int elementIndex, double elementValue ) = 0;
    
    virtual void setColLower(const double * array);

    virtual void setColUpper( int elementIndex, double elementValue ) = 0;

    virtual void setColUpper(const double * array);
    
    
    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 setRowSetBounds(const int* indexFirst,
                                 const int* indexLast,
                                 const double* boundList);
  
  
    virtual void setRowType(int index, char sense, double rightHandSide,
                            double range) = 0;
  
    virtual void setRowSetTypes(const int* indexFirst,
                                const int* indexLast,
                                const char* senseList,
                                const double* rhsList,
                                const double* rangeList);

    virtual void setColSolution(const double *colsol) = 0;

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

    virtual int reducedCostFix(double gap, bool justInteger=true);

  //-------------------------------------------------------------------------
    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);
  //-------------------------------------------------------------------------

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

    typedef std::vector<std::string> OsiNameVec ;


    virtual std::string dfltRowColName(char rc,
                                 int ndx, unsigned digits = 7) const ;

  virtual std::string getObjName (unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ;

    virtual inline void setObjName (std::string name)
    { objName_ = name ; }

    virtual std::string getRowName(int rowIndex,
                                   unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ;

    virtual const OsiNameVec &getRowNames() ;

    virtual void setRowName(int ndx, std::string name) ;

    virtual void setRowNames(OsiNameVec &srcNames,
                     int srcStart, int len, int tgtStart) ;

    virtual void deleteRowNames(int tgtStart, int len) ;
  
    virtual std::string getColName(int colIndex,
                                   unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ;

    virtual const OsiNameVec &getColNames() ;

    virtual void setColName(int ndx, std::string name) ;

    virtual void setColNames(OsiNameVec &srcNames,
                     int srcStart, int len, int tgtStart) ;

    virtual void deleteColNames(int tgtStart, int len) ;
  

    void setRowColNames(const CoinMpsIO &mps) ;

    void setRowColNames(CoinModel &mod) ;

    void setRowColNames(CoinLpIO &mod) ;

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

    virtual void addCol(const CoinPackedVectorBase& vec,
                        const double collb, const double colub,   
                        const double obj) = 0;

    virtual void addCol(const CoinPackedVectorBase& vec,
                        const double collb, const double colub,   
                        const double obj, std::string name) ;

    virtual void addCol(int numberElements,
                        const int* rows, const double* elements,
                        const double collb, const double colub,   
                        const double obj) ;

    virtual void addCol(int numberElements,
                        const int* rows, const double* elements,
                        const double collb, const double colub,   
                        const double obj, std::string name) ;

    virtual void addCols(const int numcols,
                         const CoinPackedVectorBase * const * cols,
                         const double* collb, const double* colub,   
                         const double* obj);

    virtual void addCols(const int numcols, const int* columnStarts,
                         const int* rows, const double* elements,
                         const double* collb, const double* colub,   
                         const double* obj);

    void addCols(const CoinBuild & buildObject);

    int addCols(CoinModel & modelObject);

#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 double rowlb, const double rowub,
                        std::string name) ;

    virtual void addRow(const CoinPackedVectorBase& vec,
                        const char rowsen, const double rowrhs,   
                        const double rowrng) = 0;

    virtual void addRow(const CoinPackedVectorBase& vec,
                        const char rowsen, const double rowrhs,   
                        const double rowrng, std::string name) ;

    virtual void addRow(int numberElements,
                        const int *columns, const double *element,
                        const double rowlb, const double rowub) ;

    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);

    virtual void addRows(const int numrows, const int *rowStarts,
                         const int *columns, const double *element,
                         const double *rowlb, const double *rowub);

    void addRows(const CoinBuild &buildObject);

    int addRows(CoinModel &modelObject);

#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 void replaceMatrixOptional(const CoinPackedMatrix & ) {}

    virtual void replaceMatrix(const CoinPackedMatrix & ) {abort();}

    virtual void saveBaseModel() {}

    virtual void restoreBaseModel(int numberRows);
    //-----------------------------------------------------------------------
    virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
                                          double effectivenessLb = 0.0);

    virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);

    virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);

    void deleteBranchingInfo(int numberDeleted, const int * which);


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

    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 CoinBigIndex * 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 CoinBigIndex * 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 loadFromCoinModel (CoinModel & modelObject,
                                   bool keepSolution=false);

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

    virtual int readMps (const char *filename, const char*extension,
                        int & numberSets, CoinSet ** & sets);

    virtual int readGMPL (const char *filename, const char *dataname=NULL);

    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, int numberSOS=0,
                        const CoinSet * setInfo=NULL) const ;

/***********************************************************************/
// Lp files 

  virtual void writeLp(const char *filename,
               const char *extension = "lp",
                double epsilon = 1e-5,
                int numberAcross = 10,
                int decimals = 5,
                double objSense = 0.0,
                bool useRowNames = true) const;

  virtual void writeLp(FILE *fp,
                double epsilon = 1e-5,
                int numberAcross = 10,
                int decimals = 5,
                double objSense = 0.0,
                bool useRowNames = true) const;

  int writeLpNative(const char *filename,
                    char const * const * const rowNames,
                    char const * const * const columnNames,
                    const double epsilon = 1.0e-5,
                    const int numberAcross = 10,
                    const int decimals = 5,
                    const double objSense = 0.0,
                    const bool useRowNames = true) const;

  int writeLpNative(FILE *fp,
                    char const * const * const rowNames,
                    char const * const * const columnNames,
                    const double epsilon = 1.0e-5,
                    const int numberAcross = 10,
                    const int decimals = 5,
                    const double objSense = 0.0,
                    const bool useRowNames = true) const;

  virtual int readLp(const char *filename, const double epsilon = 1e-5);

  int readLp(FILE *fp, const double epsilon = 1e-5);


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

  int differentModel(OsiSolverInterface & other, 
                     bool ignoreNames=true);
#ifdef COIN_SNAPSHOT
  virtual CoinSnapshot * snapshot(bool createArrays=true) const;
#endif
#ifdef COIN_FACTORIZATION_INFO
  virtual CoinBigIndex getSizeL() const;
  virtual CoinBigIndex getSizeU() const;
#endif


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

    void setApplicationData (void * appData);
    void setAuxiliaryInfo(OsiAuxInfo * auxiliaryInfo);

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

  virtual void passInMessageHandler(CoinMessageHandler * handler);
  void newLanguage(CoinMessages::Language language);
  inline void setLanguage(CoinMessages::Language language)
  {newLanguage(language);}
  inline CoinMessageHandler * messageHandler() const
  {return handler_;}
  inline CoinMessages messages() 
  {return messages_;}
  inline CoinMessages * messagesPointer() 
  {return &messages_;}
  inline bool defaultHandler() const
  { return defaultHandler_;}
  //---------------------------------------------------------------------------
    void findIntegers(bool justCount);
    virtual int findIntegersAndSOS(bool justCount);
    inline int numberObjects() const { return numberObjects_;}
    inline void setNumberObjects(int number) 
    {  numberObjects_=number;}

    inline OsiObject ** objects() const { return object_;}

    const inline OsiObject * object(int which) const { return object_[which];}
    inline OsiObject * modifiableObject(int which) const { return object_[which];}

    void deleteObjects();

    void addObjects(int numberObjects, OsiObject ** objects);
    double forceFeasible();
  //---------------------------------------------------------------------------

    virtual void activateRowCutDebugger (const char *modelName);

    virtual void activateRowCutDebugger(const double *solution,
                                        bool enforceOptimality = true);

    const OsiRowCutDebugger *getRowCutDebugger() const;

    OsiRowCutDebugger * getRowCutDebuggerAlways() const;
  

  virtual int canDoSimplexInterface() const ;


  virtual void enableFactorization() const ;

  virtual void disableFactorization() const ;

  virtual bool basisIsAvailable() const ;

  inline bool optimalBasisIsAvailable() const { return basisIsAvailable() ; }

  virtual void getBasisStatus(int* cstat, int* rstat) const ;

  virtual int setBasisStatus(const int* cstat, const int* rstat) ;

  virtual void getReducedGradient(double* columnReducedCosts, 
                                  double* duals, const double* c) const ;

  virtual void getBInvARow(int row, double* z, double* slack = NULL) const ;

  virtual void getBInvRow(int row, double* z) const ;

  virtual void getBInvACol(int col, double* vec) const ;

  virtual void getBInvCol(int col, double* vec) const ;

  virtual void getBasics(int* index) const ;



  virtual void enableSimplexInterface(bool doingPrimal) ;

  virtual void disableSimplexInterface() ;
  virtual int pivot(int colIn, int colOut, int outStatus) ;

  virtual int primalPivotResult(int colIn, int sign, 
                                int& colOut, int& outStatus, 
                                double& t, CoinPackedVector* dx);

  virtual int dualPivotResult(int& colIn, int& sign, 
                              int colOut, int outStatus, 
                              double& t, CoinPackedVector* dx) ;
   
  //---------------------------------------------------------------------------


    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();



    mutable OsiRowCutDebugger * rowCutDebugger_;
   // Why not just make useful stuff protected?
  CoinMessageHandler * handler_;
  bool defaultHandler_;
  CoinMessages messages_;
  int numberIntegers_;
  int numberObjects_;

  OsiObject ** object_;
  mutable char * columnType_;

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

private:

    OsiAuxInfo * appDataEtc_;
    int intParam_[OsiLastIntParam];
    double dblParam_[OsiLastDblParam];
    std::string strParam_[OsiLastStrParam];
    bool hintParam_[OsiLastHintParam];
    OsiHintStrength hintStrength_[OsiLastHintParam];
    CoinWarmStart* ws_;
    std::vector<double> strictColSolution_;

    OsiNameVec rowNames_ ;
    OsiNameVec colNames_ ;
    std::string objName_ ;

};

//#############################################################################
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