OsiClpSolverInterface.hpp

Go to the documentation of this file.

// $Id$
// 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 OsiClpSolverInterface_H
#define OsiClpSolverInterface_H

#include <string>
#include <cfloat>
#include <map>

#include "ClpSimplex.hpp"
#include "ClpLinearObjective.hpp"
#include "CoinPackedMatrix.hpp"
#include "OsiSolverInterface.hpp"
#include "CoinWarmStartBasis.hpp"
#include "ClpEventHandler.hpp"
#include "ClpNode.hpp"
#include "CoinIndexedVector.hpp"
#include "CoinFinite.hpp"

class OsiRowCut;
class OsiClpUserSolver;
class OsiClpDisasterHandler;
class CoinSet;
static const double OsiClpInfinity = COIN_DBL_MAX;

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

class OsiClpSolverInterface : virtual public OsiSolverInterface {
  friend void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);

public:
  //---------------------------------------------------------------------------
  virtual void initialSolve();

  virtual void resolve();

  virtual void resolveGub(int needed);

  virtual void branchAndBound();

  void crossover(int options, int basis);

  virtual int canDoSimplexInterface() const;

  virtual void enableFactorization() const;

  virtual void disableFactorization() const;

  virtual bool basisIsAvailable() const;

  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 getBInvARow(int row, CoinIndexedVector *z, CoinIndexedVector *slack = NULL,
    bool keepScaled = false) const;

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

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

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

  virtual void getBInvACol(CoinIndexedVector *vec) const;

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

  virtual void getBasics(int *index) const;

  virtual void enableSimplexInterface(bool doingPrimal);
  void copyEnabledSuff(OsiClpSolverInterface &rhs);

  virtual void disableSimplexInterface();
  void copyEnabledStuff(ClpSimplex &rhs);

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

  //---------------------------------------------------------------------------
  // Set an integer parameter
  bool setIntParam(OsiIntParam key, int value);
  // Set an double parameter
  bool setDblParam(OsiDblParam key, double value);
  // Set a string parameter
  bool setStrParam(OsiStrParam key, const std::string &value);
  // Get an integer parameter
  bool getIntParam(OsiIntParam key, int &value) const;
  // Get an double parameter
  bool getDblParam(OsiDblParam key, double &value) const;
  // Get a string parameter
  bool getStrParam(OsiStrParam key, std::string &value) const;
  // Set a hint parameter - overrides OsiSolverInterface
  virtual bool setHintParam(OsiHintParam key, bool yesNo = true,
    OsiHintStrength strength = OsiHintTry,
    void *otherInformation = NULL);

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

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

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

  virtual CoinWarmStart *getEmptyWarmStart() const;

  virtual CoinWarmStart *getWarmStart() const;
  inline CoinWarmStartBasis *getPointerToWarmStart()
  {
    return &basis_;
  }
  inline const CoinWarmStartBasis *getConstPointerToWarmStart() const
  {
    return &basis_;
  }
  virtual bool setWarmStart(const CoinWarmStart *warmstart);
  virtual CoinWarmStart *getPointerToWarmStart(bool &mustDelete);

  void setColumnStatus(int iColumn, ClpSimplex::Status status);


  //---------------------------------------------------------------------------
  virtual void markHotStart();
  virtual void solveFromHotStart();
  virtual void unmarkHotStart();
  int startFastDual(int options);
  void stopFastDual();
  void setStuff(double tolerance, double increment);
  OsiRowCut *smallModelCut(const double *originalLower, const double *originalUpper,
    int numberRowsAtContinuous, const int *whichGenerator,
    int typeCut = 0);
  OsiRowCut *modelCut(const double *originalLower, const double *originalUpper,
    int numberRowsAtContinuous, const int *whichGenerator,
    int typeCut = 0);

  //---------------------------------------------------------------------------
  virtual int getNumCols() const
  {
    return modelPtr_->numberColumns();
  }

  virtual int getNumRows() const
  {
    return modelPtr_->numberRows();
  }

  virtual CoinBigIndex getNumElements() const
  {
    CoinBigIndex retVal = 0;
    const CoinPackedMatrix *matrix = modelPtr_->matrix();
    if (matrix != NULL)
      retVal = matrix->getNumElements();
    return retVal;
  }

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

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

  virtual const double *getColLower() const { return modelPtr_->columnLower(); }

  virtual const double *getColUpper() const { return modelPtr_->columnUpper(); }

  virtual const char *getRowSense() const;

  virtual const double *getRightHandSide() const;

  virtual const double *getRowRange() const;

  virtual const double *getRowLower() const { return modelPtr_->rowLower(); }

  virtual const double *getRowUpper() const { return modelPtr_->rowUpper(); }

  virtual const double *getObjCoefficients() const
  {
    if (fakeMinInSimplex_)
      return linearObjective_;
    else
      return modelPtr_->objective();
  }

  virtual double getObjSense() const
  {
    return ((fakeMinInSimplex_) ? -modelPtr_->optimizationDirection() : modelPtr_->optimizationDirection());
  }

  virtual bool isContinuous(int colNumber) const;
  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 char *getColType(bool refresh = false) const;

  bool isOptionalInteger(int colIndex) const;
  void setOptionalInteger(int index);
  inline bool isHeuristicInteger(int colIndex) const
  {
    return (integerInformation_ && integerInformation_[colIndex] == 1);
  }
  inline int integerType(int colIndex) const
  {
    return integerInformation_ ? integerInformation_[colIndex] : 0;
  }
  inline void setIntegerType(int colIndex, int value)
  {
    integerInformation_[colIndex] = static_cast< char >(value);
  }
  virtual const CoinPackedMatrix *getMatrixByRow() const;

  virtual const CoinPackedMatrix *getMatrixByCol() const;

  virtual CoinPackedMatrix *getMutableMatrixByCol() const;

  virtual double getInfinity() const { return OsiClpInfinity; }

  virtual const double *getColSolution() const;

  virtual const double *getRowPrice() const;

  virtual const double *getReducedCost() const;

  virtual const double *getRowActivity() const;

  virtual double getObjValue() const;

  virtual int getIterationCount() const
  {
    return modelPtr_->numberIterations();
  }

  virtual std::vector< double * > getDualRays(int maxNumRays,
    bool fullRay = false) const;
  virtual std::vector< double * > getPrimalRays(int maxNumRays) const;



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

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

  virtual void setColLower(int elementIndex, double elementValue);

  virtual void setColUpper(int elementIndex, double elementValue);

  virtual void setColBounds(int elementIndex,
    double lower, double upper);

  virtual void setColSetBounds(const int *indexFirst,
    const int *indexLast,
    const double *boundList);

  virtual void setRowLower(int elementIndex, double elementValue);

  virtual void setRowUpper(int elementIndex, double elementValue);

  virtual void setRowBounds(int elementIndex,
    double lower, double upper);

  virtual void setRowType(int index, char sense, double rightHandSide,
    double range);

  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 setObjective(const double *array);

  virtual void setColLower(const double *array);

  virtual void setColUpper(const double *array);

  //    using OsiSolverInterface::setRowName ;
  //    virtual void setRowName(int rowIndex, std::string & name) ;
  virtual void setRowName(int rowIndex, std::string name);

  //    using OsiSolverInterface::setColName ;
  //    virtual void setColName(int colIndex, std::string & name) ;
  virtual void setColName(int colIndex, std::string name);


  //-------------------------------------------------------------------------
  virtual void setContinuous(int index);
  virtual void setInteger(int index);
  virtual void setContinuous(const int *indices, int len);
  virtual void setInteger(const int *indices, int len);
  inline int numberSOS() const
  {
    return numberSOS_;
  }
  inline const CoinSet *setInfo() const
  {
    return setInfo_;
  }
  void replaceSetInfo(int numberSOS, CoinSet *setInfo);
  virtual int findIntegersAndSOS(bool justCount);

  //-------------------------------------------------------------------------
  virtual void setObjSense(double s)
  {
    modelPtr_->setOptimizationDirection(s < 0 ? -1 : 1);
  }

  virtual void setColSolution(const double *colsol);

  virtual void setRowPrice(const double *rowprice);

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

  //using OsiSolverInterface::addCol ;
  virtual void addCol(const CoinPackedVectorBase &vec,
    const double collb, const double colub,
    const double obj);
  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);
  virtual void deleteCols(const int num, const int *colIndices);

  virtual void addRow(const CoinPackedVectorBase &vec,
    const double rowlb, const double rowub);
  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);
  virtual void addRow(int numberElements, const int *columns, const double *element,
    const double rowlb, const double rowub);
  virtual void addRow(const CoinPackedVectorBase &vec,
    const char rowsen, const double rowrhs,
    const double rowrng, std::string name);
  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 modifyCoefficient(int row, int column, double newElement,
    bool keepZero = false)
  {
    modelPtr_->modifyCoefficient(row, column, newElement, keepZero);
  }

  virtual void deleteRows(const int num, const int *rowIndices);
  virtual void saveBaseModel();
  virtual void restoreBaseModel(int numberRows);

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



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

public:
  virtual void loadProblem(const CoinPackedMatrix &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub);

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

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

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

  virtual void loadProblem(const ClpMatrixBase &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub);

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

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

  using OsiSolverInterface::readMps;
  virtual int readMps(const char *filename,
    const char *extension = "mps");
  int readMps(const char *filename, bool keepNames, bool allowErrors);
  virtual int readMps(const char *filename, const char *extension,
    int &numberSets, CoinSet **&sets);

  virtual void writeMps(const char *filename,
    const char *extension = "mps",
    double objSense = 0.0) const;
  virtual int writeMpsNative(const char *filename,
    const char **rowNames, const char **columnNames,
    int formatType = 0, int numberAcross = 2,
    double objSense = 0.0) const;
  virtual int readLp(const char *filename, const double epsilon = 1e-5);
  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;
  virtual void replaceMatrixOptional(const CoinPackedMatrix &matrix);
  virtual void replaceMatrix(const CoinPackedMatrix &matrix);

  virtual void passInMessageHandler(CoinMessageHandler *handler);
  void newLanguage(CoinMessages::Language language);
  void setLanguage(CoinMessages::Language language)
  {
    newLanguage(language);
  }
  void setLogLevel(int value);
  void generateCpp(FILE *fp);
  //---------------------------------------------------------------------------

  ClpSimplex *getModelPtr() const;
  inline ClpSimplex *swapModelPtr(ClpSimplex *newModel)
  {
    ClpSimplex *model = modelPtr_;
    modelPtr_ = newModel;
    return model;
  }
  inline unsigned int specialOptions() const
  {
    return specialOptions_;
  }
  void setSpecialOptions(unsigned int value);
  inline int lastAlgorithm() const
  {
    return lastAlgorithm_;
  }
  inline void setLastAlgorithm(int value)
  {
    lastAlgorithm_ = value;
  }
  inline int cleanupScaling() const
  {
    return cleanupScaling_;
  }
  inline void setCleanupScaling(int value)
  {
    cleanupScaling_ = value;
  }
  inline double smallestElementInCut() const
  {
    return smallestElementInCut_;
  }
  inline void setSmallestElementInCut(double value)
  {
    smallestElementInCut_ = value;
  }
  inline double smallestChangeInCut() const
  {
    return smallestChangeInCut_;
  }
  inline void setSmallestChangeInCut(double value)
  {
    smallestChangeInCut_ = value;
  }
  inline void setSolveOptions(const ClpSolve &options)
  {
    solveOptions_ = options;
  }
  virtual int tightenBounds(int lightweight = 0);
  int infeasibleOtherWay(char *whichWay);
  virtual CoinBigIndex getSizeL() const;
  virtual CoinBigIndex getSizeU() const;
  const OsiClpDisasterHandler *disasterHandler() const
  {
    return disasterHandler_;
  }
  void passInDisasterHandler(OsiClpDisasterHandler *handler);
  ClpLinearObjective *fakeObjective() const
  {
    return fakeObjective_;
  }
  void setFakeObjective(ClpLinearObjective *fakeObjective);
  void setFakeObjective(double *fakeObjective);
  void setupForRepeatedUse(int senseOfAdventure = 0, int printOut = 0);
  virtual void synchronizeModel();
  void setSpecialOptionsMutable(unsigned int value) const;


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

  OsiClpSolverInterface();

  virtual OsiSolverInterface *clone(bool copyData = true) const;

  OsiClpSolverInterface(const OsiClpSolverInterface &);

  OsiClpSolverInterface(ClpSimplex *rhs, bool reallyOwn = false);

  void releaseClp();

  OsiClpSolverInterface &operator=(const OsiClpSolverInterface &rhs);

  virtual ~OsiClpSolverInterface();

  virtual void reset();

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

protected:


  virtual void applyRowCut(const OsiRowCut &rc);

  virtual void applyColCut(const OsiColCut &cc);

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

protected:
  void gutsOfDestructor();

  void freeCachedResults() const;

  void freeCachedResults0() const;

  void freeCachedResults1() const;

  void extractSenseRhsRange() const;

  void fillParamMaps();
  CoinWarmStartBasis getBasis(ClpSimplex *model) const;
  void setBasis(const CoinWarmStartBasis &basis, ClpSimplex *model);
  void crunch();
  void redoScaleFactors(int numberRows, const CoinBigIndex *starts,
    const int *indices, const double *elements);

public:
  void setBasis(const CoinWarmStartBasis &basis);
  inline void setBasis()
  {
    setBasis(basis_, modelPtr_);
  }
  CoinWarmStartDiff *getBasisDiff(const unsigned char *statusArray) const;
  CoinWarmStartBasis *getBasis(const unsigned char *statusArray) const;
  void deleteScaleFactors();
  inline const double *upRange() const
  {
    return rowActivity_;
  }
  inline const double *downRange() const
  {
    return columnActivity_;
  }
  inline void passInRanges(int *array)
  {
    whichRange_ = array;
  }
  void setSOSData(int numberSOS, const char *type,
    const int *start, const int *indices, const double *weights = NULL);
  void computeLargestAway();
  inline double largestAway() const
  {
    return largestAway_;
  }
  inline void setLargestAway(double value)
  {
    largestAway_ = value;
  }
  void lexSolve();
  inline ClpSimplex *getContinuousModel() const
  {
    return continuousModel_;
  }
  inline void setContinuousModel(ClpSimplex *model)
  {
    continuousModel_ = model;
  }

protected:
  mutable ClpSimplex *modelPtr_;

  mutable char *rowsense_;

  mutable double *rhs_;

  mutable double *rowrange_;

  mutable CoinWarmStartBasis *ws_;
  mutable double *rowActivity_;
  mutable double *columnActivity_;
  ClpNodeStuff stuff_;
  int numberSOS_;
  CoinSet *setInfo_;
  ClpSimplex *smallModel_;
  ClpFactorization *factorization_;
  double smallestElementInCut_;
  double smallestChangeInCut_;
  double largestAway_;
  char *spareArrays_;
  CoinWarmStartBasis basis_;
  int itlimOrig_;

  mutable int lastAlgorithm_;

  bool notOwned_;

  mutable CoinPackedMatrix *matrixByRow_;

  CoinPackedMatrix *matrixByRowAtContinuous_;

  char *integerInformation_;

  int *whichRange_;

  //std::map<OsiIntParam, ClpIntParam> intParamMap_;
  //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
  //std::map<OsiStrParam, ClpStrParam> strParamMap_;

  mutable bool fakeMinInSimplex_;
  mutable double *linearObjective_;

  mutable ClpDataSave saveData_;
  ClpSolve solveOptions_;
  int cleanupScaling_;
  mutable unsigned int specialOptions_;
  ClpSimplex *baseModel_;
  int lastNumberRows_;
  ClpSimplex *continuousModel_;
  OsiClpDisasterHandler *disasterHandler_;
  ClpLinearObjective *fakeObjective_;
  CoinDoubleArrayWithLength rowScale_;
  CoinDoubleArrayWithLength columnScale_;
};

class OsiClpDisasterHandler : public ClpDisasterHandler {
public:
  virtual void intoSimplex();
  virtual bool check() const;
  virtual void saveInfo();
  virtual int typeOfDisaster();

  OsiClpDisasterHandler(OsiClpSolverInterface *model = NULL);
  virtual ~OsiClpDisasterHandler();
  // Copy
  OsiClpDisasterHandler(const OsiClpDisasterHandler &);
  // Assignment
  OsiClpDisasterHandler &operator=(const OsiClpDisasterHandler &);
  virtual ClpDisasterHandler *clone() const;


  void setOsiModel(OsiClpSolverInterface *model);
  inline OsiClpSolverInterface *osiModel() const
  {
    return osiModel_;
  }
  inline void setWhereFrom(int value)
  {
    whereFrom_ = value;
  }
  inline int whereFrom() const
  {
    return whereFrom_;
  }
  inline void setPhase(int value)
  {
    phase_ = value;
  }
  inline int phase() const
  {
    return phase_;
  }
  bool inTrouble() const;


protected:
  OsiClpSolverInterface *osiModel_;
  int whereFrom_;
  int phase_;
  bool inTrouble_;
};
// So unit test can find out if NDEBUG set
bool OsiClpHasNDEBUG();
//#############################################################################
void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
#endif

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/