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