Osi/Doxygen/OsiXprSolverInterface_8hpp_source.html

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

#define OsiXprSolverInterface_H


#include <string>

#include <cstdio>


#include "OsiSolverInterface.hpp"


typedef struct xo_prob_struct *XPRSprob;


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


class OsiXprSolverInterface : virtual public OsiSolverInterface {

  friend void OsiXprSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);


public:

  virtual void initialSolve();


  virtual void resolve();


  virtual void branchAndBound();


  // 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 mipstart option (pass column solution to XPRESS before MIP start)

  void setMipStart(bool value) { domipstart = value; }

  // Get mipstart option value

  bool getMipStart() const { return domipstart; }


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


  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;


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

  CoinWarmStart *getEmptyWarmStart() const;

  virtual CoinWarmStart *getWarmStart() const;

  virtual bool setWarmStart(const CoinWarmStart *warmstart);


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

  virtual void markHotStart();

  virtual void solveFromHotStart();

  virtual void unmarkHotStart();


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

  virtual int getNumCols() const;


  virtual int getNumRows() const;


  virtual int getNumElements() const;


  virtual const double *getColLower() const;


  virtual const double *getColUpper() const;


  virtual const char *getRowSense() const;


  virtual const double *getRightHandSide() const;


  virtual const double *getRowRange() const;


  virtual const double *getRowLower() const;


  virtual const double *getRowUpper() const;


  virtual const double *getObjCoefficients() const;


  virtual double getObjSense() const;


  virtual bool isContinuous(int colIndex) const;


#if 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;

#endif

  virtual const CoinPackedMatrix *getMatrixByRow() const;


  virtual const CoinPackedMatrix *getMatrixByCol() const;


  virtual double getInfinity() const;


  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;


  virtual std::vector< double * > getDualRays(int maxNumRays,

    bool fullRay = false) const;

  virtual std::vector< double * > getPrimalRays(int maxNumRays) const;


#if 0


      virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)

        const;

#endif


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


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

  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 setContinuous(int index);

  virtual void setInteger(int index);

  virtual void setContinuous(const int *indices, int len);

  virtual void setInteger(const int *indices, int len);


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

  virtual void setObjSense(double s);


  virtual void setColSolution(const double *colsol);


  virtual void setRowPrice(const double *rowprice);


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

  virtual void addCol(const CoinPackedVectorBase &vec,

    const double collb, const double colub,

    const double obj);

  virtual void addCols(const int numcols,

    const CoinPackedVectorBase *const *cols,

    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 char rowsen, const double rowrhs,

    const double rowrng);

  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 deleteRows(const int num, const int *rowIndices);

#if 0

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

      virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,

                                            double effectivenessLb = 0.0);


#endif

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


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


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


  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;


  void passInMessageHandler(CoinMessageHandler *handler);


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


  static void incrementInstanceCounter();


  static void decrementInstanceCounter();


  static unsigned int getNumInstances();


  XPRSprob getLpPtr() { return prob_; }


  static int version();


  static int iXprCallCount_;


  static FILE *getLogFilePtr();

  static void setLogFileName(const char *filename);


  OsiXprSolverInterface(int newrows = 50, int newnz = 100);


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


  OsiXprSolverInterface(const OsiXprSolverInterface &);


  OsiXprSolverInterface &operator=(const OsiXprSolverInterface &rhs);


  virtual ~OsiXprSolverInterface();


  /***************************************************************************/


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


protected:

  virtual void applyRowCut(const OsiRowCut &rc);


  virtual void applyColCut(const OsiColCut &cc);


private:

  static const char *logFileName_;


  static FILE *logFilePtr_;


  static unsigned int numInstances_;


  static unsigned int osiSerial_;


  void gutsOfCopy(const OsiXprSolverInterface &source);


  void gutsOfConstructor();


  void gutsOfDestructor();


  void freeSolution();


  void freeCachedResults();


  int getNumIntVars() const;


  void getVarTypes() const;


  void activateMe() const;


  bool isDataLoaded() const;


  mutable XPRSprob prob_;


  mutable std::string xprProbname_;


  mutable CoinPackedMatrix *matrixByRow_;

  mutable CoinPackedMatrix *matrixByCol_;


  mutable double *colupper_;


  mutable double *collower_;


  mutable double *rowupper_;


  mutable double *rowlower_;


  mutable char *rowsense_;


  mutable double *rhs_;


  mutable double *rowrange_;


  mutable double *objcoeffs_;


  mutable double objsense_;


  mutable double *colsol_;


  mutable double *rowsol_;


  mutable double *rowact_;


  mutable double *rowprice_;


  mutable double *colprice_;


  mutable int *ivarind_;


  mutable char *ivartype_;


  mutable char *vartype_;


  mutable bool lastsolvewasmip;


  bool domipstart;

};


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

void OsiXprSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);


#endif


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

*/