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 CoinBigIndex 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);
  }
 
  inline void setColumnType(int iColumn, char type)
  {
    if (!columnType_)
      getColType(true);
    columnType_[iColumn] = type;
  }
 
  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 CoinBigIndex *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 CoinBigIndex *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 = 9,
    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);
  void statistics(double &minimumNegative, double &maximumNegative,
    double &minimumPositive, double &maximumPositive,
    int type = 3) const;
#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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/