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