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

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