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