OsiTestSolverInterface.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
// This file is licensed under the terms of Eclipse Public License (EPL).
 
// this is a copy of OsiVolSolverInterface (trunk rev. 1466) renamed to OsiTestSolverInterface
 
#ifndef OsiTestSolverInterface_H
#define OsiTestSolverInterface_H
 
#include <string>
 
#include "OsiTestSolver.hpp"
 
#include "CoinPackedMatrix.hpp"
 
#include "OsiSolverInterface.hpp"
 
static const double OsiTestInfinity = 1.0e31;
 
//#############################################################################
 
class OsiTestSolverInterface :
   virtual public OsiSolverInterface, public VOL_user_hooks {
   friend void OsiTestSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
 
private:
  class OsiVolMatrixOneMinusOne_ {
    int majorDim_;
    int minorDim_;
 
    int plusSize_;
    int * plusInd_;
    int * plusStart_;
    int * plusLength_;
 
    int minusSize_;
    int * minusInd_;
    int * minusStart_;
    int * minusLength_;
 
  public:
    OsiVolMatrixOneMinusOne_(const CoinPackedMatrix& m);
    ~OsiVolMatrixOneMinusOne_();
    void timesMajor(const double* x, double* y) const;
  };
 
public:
  //---------------------------------------------------------------------------
    virtual void initialSolve();
 
    virtual void resolve();
 
    virtual void branchAndBound() {
      throw CoinError("Sorry, the Volume Algorithm doesn't implement B&B",
                     "branchAndBound", "OsiTestSolverInterface");
    }
 
  //---------------------------------------------------------------------------
    // 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;
 
  //---------------------------------------------------------------------------
 
    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;
    virtual bool setWarmStart(const CoinWarmStart* warmstart);
 
  //---------------------------------------------------------------------------
    virtual void markHotStart();
    virtual void solveFromHotStart();
    virtual void unmarkHotStart();
 
  //---------------------------------------------------------------------------
      virtual int getNumCols() const {
        return rowMatrixCurrent_?
        rowMatrix_.getNumCols() : colMatrix_.getNumCols(); }
  
      virtual int getNumRows() const {
        return rowMatrixCurrent_?
        rowMatrix_.getNumRows() : colMatrix_.getNumRows(); }
  
      virtual int getNumElements() const {
        return rowMatrixCurrent_?
        rowMatrix_.getNumElements() : colMatrix_.getNumElements(); }
  
      virtual const double * getColLower() const { return collower_; }
  
      virtual const double * getColUpper() const { return colupper_; }
  
      virtual const char * getRowSense() const { return rowsense_; }
  
      virtual const double * getRightHandSide() const { return rhs_; }
  
      virtual const double * getRowRange() const { return rowrange_; }
  
      virtual const double * getRowLower() const { return rowlower_; }
  
      virtual const double * getRowUpper() const { return rowupper_; }
  
      virtual const double * getObjCoefficients() const { return objcoeffs_; }
  
      virtual double getObjSense() const { return objsense_; }
  
      virtual bool isContinuous(int colNumber) const;
  
#if 0
      virtual bool isBinary(int colNumber) const;
  
      virtual bool isInteger(int colNumber) const;
  
      virtual bool isIntegerNonBinary(int colNumber) const;
  
      virtual bool isFreeBinary(int colNumber) const;
#endif
  
      virtual const CoinPackedMatrix * getMatrixByRow() const;
  
      virtual const CoinPackedMatrix * getMatrixByCol() const;
  
      virtual double getInfinity() const { return OsiTestInfinity; }
    
      virtual const double * getColSolution() const { return colsol_; }
  
      virtual const double * getRowPrice() const { return rowprice_; }
  
      virtual const double * getReducedCost() const { return rc_; }
  
      virtual const double * getRowActivity() const { return lhs_; }
  
      virtual double getObjValue() const { 
#if 1
        // This does not pass unitTest if getObjValue is called before solve
        return lagrangeanCost_;
#else
        return OsiSolverInterface::getObjValue();
#endif
      }
  
      virtual int getIterationCount() const { return volprob_.iter(); }
  
      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 ) {
        objcoeffs_[elementIndex] = elementValue;
      }
 
      using OsiSolverInterface::setColLower ;
      virtual void setColLower( int elementIndex, double elementValue ) {
        collower_[elementIndex] = elementValue;
      }
      
      using OsiSolverInterface::setColUpper ;
      virtual void setColUpper( int elementIndex, double elementValue ) {
        colupper_[elementIndex] = elementValue;
      }
 
      virtual void setColBounds( int elementIndex,
                                 double lower, double upper ) {
        collower_[elementIndex] = lower;
        colupper_[elementIndex] = upper;
      }
 
      virtual void setColSetBounds(const int* indexFirst,
                                   const int* indexLast,
                                   const double* boundList);
      
      virtual void setRowLower( int elementIndex, double elementValue ) {
        rowlower_[elementIndex] = elementValue;
        convertBoundToSense(elementValue, rowupper_[elementIndex],
                            rowsense_[elementIndex], rhs_[elementIndex],
                            rowrange_[elementIndex]);
      }
      
      virtual void setRowUpper( int elementIndex, double elementValue ) {
        rowupper_[elementIndex] = elementValue;
        convertBoundToSense(rowlower_[elementIndex], elementValue,
                            rowsense_[elementIndex], rhs_[elementIndex],
                            rowrange_[elementIndex]);
      }
    
      virtual void setRowBounds( int elementIndex,
                                 double lower, double upper ) {
        rowlower_[elementIndex] = lower;
        rowupper_[elementIndex] = upper;
        convertBoundToSense(lower, upper,
                            rowsense_[elementIndex], rhs_[elementIndex],
                            rowrange_[elementIndex]);
      }
    
      virtual void setRowType(int index, char sense, double rightHandSide,
                              double range) {
        rowsense_[index] = sense;
        rhs_[index] = rightHandSide;
        rowrange_[index] = range;
        convertSenseToBound(sense, rightHandSide, range,
                            rowlower_[index], rowupper_[index]);
      }
    
      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 ) { objsense_ = s < 0 ? -1.0 : 1.0; }
    
    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);
 
      using OsiSolverInterface::addCols ;
      virtual void addCols(const int numcols,
                           const CoinPackedVectorBase * const * cols,
                           const double* collb, const double* colub,   
                           const double* obj);
#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);
    
      using OsiSolverInterface::addRow ;
      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);
 
      using OsiSolverInterface::addRows ;
      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);
#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);
    
      //-----------------------------------------------------------------------
#if 0
 
      virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
                                            double effectivenessLb = 0.0);
#endif
 
 
 
  //---------------------------------------------------------------------------
 
protected:
  void initFromRlbRub(const int rownum,
                      const double* rowlb, const double* rowub);
  void initFromRhsSenseRange(const int rownum, const char* rowsen,
                             const double* rowrhs, const double* rowrng);
  void initFromClbCubObj(const int colnum, const double* collb,
                         const double* colub, const double* obj);
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 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);
    
    using OsiSolverInterface::readMps ;
    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;
 
  //---------------------------------------------------------------------------
 
    VOL_problem* volprob() { return &volprob_; }
 
  //---------------------------------------------------------------------------
 
    OsiTestSolverInterface ();
    
    virtual OsiSolverInterface * clone(bool copyData = true) const;
    
    OsiTestSolverInterface (const OsiTestSolverInterface &);
    
    OsiTestSolverInterface & operator=(const OsiTestSolverInterface& rhs);
    
    virtual ~OsiTestSolverInterface ();
 
  //---------------------------------------------------------------------------
 
protected:
 
 
    virtual void applyRowCut(const OsiRowCut& rc);
 
    virtual void applyColCut(const OsiColCut& cc);
 
  //---------------------------------------------------------------------------
 
private:
    virtual int compute_rc(const VOL_dvector& u, VOL_dvector& rc);
    virtual int solve_subproblem(const VOL_dvector& dual,
                                 const VOL_dvector& rc,
                                 double& lcost, VOL_dvector& x, VOL_dvector& v,
                                 double& pcost);
  virtual int heuristics(const VOL_problem& /*p*/, 
                         const VOL_dvector& /*x*/, double& heur_val) {
      heur_val = COIN_DBL_MAX;
      return 0;
    }
 
  //---------------------------------------------------------------------------
 
private:
    void updateRowMatrix_() const;
    void updateColMatrix_() const;
 
    void checkData_() const;
    void compute_rc_(const double* u, double* rc) const;
    void gutsOfDestructor_();
 
    void rowRimAllocator_();
    void colRimAllocator_();
 
    void rowRimResize_(const int newSize);
    void colRimResize_(const int newSize);
 
    void convertBoundsToSenses_();
    void convertSensesToBounds_();
 
    bool test_zero_one_minusone_(const CoinPackedMatrix& m) const;
 
  //---------------------------------------------------------------------------
 
private:
  
  //---------------------------------------------------------------------------
    mutable bool rowMatrixCurrent_;
    mutable CoinPackedMatrix rowMatrix_;
    mutable bool colMatrixCurrent_;
    mutable CoinPackedMatrix colMatrix_;
 
  //---------------------------------------------------------------------------
    bool isZeroOneMinusOne_;
    OsiVolMatrixOneMinusOne_* rowMatrixOneMinusOne_;
    OsiVolMatrixOneMinusOne_* colMatrixOneMinusOne_;
 
  //---------------------------------------------------------------------------
    double  *colupper_;
    double  *collower_;
    bool    *continuous_;
    double  *rowupper_;
    double  *rowlower_;
    char    *rowsense_;
    double  *rhs_;
    double  *rowrange_;
    double  *objcoeffs_;
 
  //---------------------------------------------------------------------------
  double  objsense_;
 
  //---------------------------------------------------------------------------
    double  *colsol_;
    double  *rowprice_;
    double  *rc_;
    double  *lhs_;
    double   lagrangeanCost_;
 
  //---------------------------------------------------------------------------
  double  *rowpriceHotStart_;
 
  int maxNumrows_;
  int maxNumcols_;
 
  VOL_problem volprob_;
};
 
void
OsiTestSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
 
#endif