OsiNullSolverInterface2.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef OsiNullSolverInterface_H
#define OsiNullSolverInterface_H

#include <string>
#include <vector>

#include "CoinMessageHandler.hpp"
#include "CoinPackedVectorBase.hpp"

#include "OsiData.hpp"
#include "OsiCollections.hpp"
#include "OsiSolverParameters.hpp"

class CoinPackedMatrix;
class CoinWarmStart;

class OsiCuts;
class OsiAuxInfo;
class OsiRowCut;
class OsiRowCutDebugger;
class CoinSet;
class CoinBuild;
class CoinModel;
class OsiSolverBranch;
class OsiSolverResult;
#include "CoinFinite.hpp"

#ifndef COIN_DBL_MAX
static const double OsiNullInfinity = DBL_MAX;
#else
static const double OsiNullInfinity = COIN_DBL_MAX;
#endif

//#############################################################################

class OsiNullSolverInterface : public OsiSolverInterface  {

public:

   virtual void initialSolve(){
      CoinAssertHint(0, "OsiNull does not have a solver");
   }; 
   
   virtual void resolve(){
      CoinAssertHint(0, "OsiNull does not have a solver");
   }
   
   virtual void branchAndBound(){
      CoinAssertHint(0, "OsiNull does not have a solver");
   }
   // Set an integer parameter
   // copy all parameters in this section from one solver to another
   void copyParameters(OsiNullSolverInterface & rhs);

   //------------------------------------------------------------------------

   virtual bool isAbandoned() const{
      CoinAssertHint(0, "OsiNull does not have a solver");
      return false;
   }
   virtual bool isProvenOptimal() const{
      CoinAssertHint(0, "OsiNull does not have a solver");
      return false;
   }
   virtual bool isProvenPrimalInfeasible() const{
      CoinAssertHint(0, "OsiNull does not have a solver");
      return false;
   }
   virtual bool isProvenDualInfeasible() const{
      CoinAssertHint(0, "OsiNull does not have a solver");
      return false;
   }
   virtual bool isPrimalObjectiveLimitReached() const{
      CoinAssertHint(0, "OsiNull does not have a solver");
      return false;
   }
   virtual bool isDualObjectiveLimitReached() const{
      CoinAssertHint(0, "OsiNull does not have a solver");
      return false;
   }
   virtual bool isIterationLimitReached() const{
      CoinAssertHint(0, "OsiNull does not have a solver");
      return false;
   }

   //------------------------------------------------------------------------
   virtual CoinWarmStart *getEmptyWarmStart () const {
      CoinAssertHint(0, "OsiNull does not have a solver");
      return NULL;
   }

   virtual CoinWarmStart* getWarmStart() const {
      CoinAssertHint(0, "OsiNull does not have a solver");
      return NULL;
   }

   virtual bool setWarmStart(const CoinWarmStart* warmstart){
      CoinAssertHint(0, "OsiNull does not have a solver");
      return false;
   }

   //------------------------------------------------------------------------
   virtual int getNumCols() const {
      return data_->getNcol();
   };
  
   virtual int getNumRows() const {
      return data_->getNrow();
   };
  
   virtual int getNumElements() const {
      const CoinPackedMatrix * Mrow = data_->getMatrixByRow();
      const CoinPackedMatrix * Mcol = data_->getMatrixByCol();
      if(Mrow){
         return Mrow->getNumElements();
      } else if(Mcol){
         return Mcol->getNumElements();
      }
      return 0;
   };

   virtual int getNumIntegers() const {
      int i, nInt = 0;
      const char * colType = data_->getColType();
      for(i = 0; i < getNumCols(); i++){
         if(colType[i] == 'B' || colType[i] == 'I')
            nInt++;
      }
      return nInt;
   }
  
   virtual const double * getColLower() const {
      return data_->getColLower();
   }
   
   virtual const double * getColUpper() const {
      return data_->getColUpper();
   }
   
   virtual const char * getRowSense() const {
  
      return data_->getRowSense();
   }

   virtual const double * getRightHandSide() const {
  
      return data_->getRowRhs();
   }

   virtual const double * getRowRange() const {
      return data_->getRowRange();
   }

   virtual const double * getRowLower() const {
      return data_->getRowLower();
   }
  
   virtual const double * getRowUpper() const {
      return data_->getRowUpper();
   }
  
   virtual const double * getObjCoefficients() const {
      return data_->getObj();
   }
  
   virtual double getObjSense() const {
      CoinAssertHint(0, "Sorry, not implemented yet.");
      return 1;
   }

   virtual bool isContinuous(int colIndex) const {
      return data_->getColType()[colIndex] == 'C';
   }
  
   virtual bool isBinary(int colIndex) const {
      return data_->getColType()[colIndex] == 'B';
   }
  
   virtual bool isInteger(int colIndex) const {
      return (data_->getColType()[colIndex] == 'B' || 
              data_->getColType()[colIndex] == 'I' ); 
   }
    
   virtual const CoinPackedMatrix * getMatrixByRow() const {
      return data_->getMatrixByRow();
   }
  
   virtual const CoinPackedMatrix * getMatrixByCol() const {
      return data_->getMatrixByCol();
   }
   virtual double getInfinity() const {
      return data_->getInfinity();
   }
    
   virtual const double * getColSolution() const {
      return data_->getPrimalSol();
   }
  
   //TODO: let user enter dual sol also
   virtual const double * getRowPrice() const {
      CoinAssertHint(0, "Sorry, not implemented yet.");
      return NULL;
   }
  
   virtual const double * getReducedCost() const {
      CoinAssertHint(0, "Sorry, not implemented yet.");
      return NULL;
   }
  
   virtual const double * getRowActivity() const {
      return data_->getRowActivity();
   }
  
   virtual double getObjValue() const {
      CoinAssertHint(0, "Sorry, not implemented yet.");
      return 0.0;
   }
   
   virtual int getIterationCount() const {
      CoinAssertHint(0, "OsiNull does not have a solver");
   }
  
   virtual std::vector<double*> getDualRays(int maxNumRays) const {
      CoinAssertHint(0, "OsiNull does not have a solver");
   }

   virtual std::vector<double*> getPrimalRays(int maxNumRays) const {
      CoinAssertHint(0, "OsiNull does not have a solver");
   }
  
   //-------------------------------------------------------------------------

   virtual void setObjCoeff( int elementIndex, double elementValue ) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void setColLower( int elementIndex, double elementValue ) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void setColUpper( int elementIndex, double elementValue ) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }
  
   virtual void setRowLower( int elementIndex, double elementValue ) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }
      
   virtual void setRowUpper( int elementIndex, double elementValue ) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }
    
   virtual void setRowType(int index, char sense, double rightHandSide,
                           double range) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void setObjSense(double s) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void setColType(const char * colType){
      data_->setColType(colType);
   }
  
   /*
     Set the primal solution variable values
    
     colsol[getNumCols()] is an array of values for the primal variables.
     These values are copied to memory owned by the solver interface object
     or the solver.  They will be returned as the result of getColSolution()
     until changed by another call to setColSolution() or by a call to any
     solver routine.  Whether the solver makes use of the solution in any
     way is solver-dependent.
   */
   virtual void setColSolution(const double *colsol) {
      data_->setPrimalSol(colsol);
   }


   virtual void setRowPrice(const double * rowprice) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   //-------------------------------------------------------------------------
   virtual void setContinuous(int index) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void setInteger(int index) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   //-------------------------------------------------------------------------
    
   //-------------------------------------------------------------------------
   virtual void addCol(const CoinPackedVectorBase& vec,
                       const double collb, const double colub,   
                       const double obj) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void deleteCols(const int num, const int * colIndices) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }
    
   virtual void addRow(const CoinPackedVectorBase& vec,
                       const double rowlb, const double rowub) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void addRow(const CoinPackedVectorBase& vec,
                       const char rowsen, const double rowrhs,   
                       const double rowrng) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void deleteRows(const int num, const int * rowIndices) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }
    


   //---------------------------------------------------------------------
   //TODO: ugh force both row/col format?
   void loadDataAndSolution(const CoinPackedMatrix & rowMatrix,
                            const CoinPackedMatrix & colMatrix,
                            const double           * collb, 
                            const double           * colub,   
                            const double           * obj,
                            const double           * rowlb, 
                            const double           * rowub,
                            const char             * colType,
                            const double           * primalSol,
                            const double             infinity){
      data_->setMatrixByRow(&rowMatrix);
      data_->setMatrixByCol(&colMatrix);      
      data_->setNrow(rowMatrix.getNumRows());
      data_->setNcol(rowMatrix.getNumCols());
      data_->setColLower(collb);
      data_->setColUpper(colub);
      data_->setRowLower(rowlb);
      data_->setRowUpper(rowub);
      data_->setObj(obj);
      data_->setColType(colType);
      data_->setPrimalSol(primalSol);
      data_->setInfinity(infinity);
      data_->initializeOtherData();
   }




   virtual void loadProblem(const CoinPackedMatrix & matrix,
                            const double * collb, 
                            const double * colub,   
                            const double * obj,
                            const double * rowlb, 
                            const double * rowub){
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   //TODO: version that passes in rhs/ranges/sense and converts to bounds
                
   virtual void assignProblem(CoinPackedMatrix*& matrix,
                              double*& collb, double*& colub, double*& obj,
                              double*& rowlb, double*& rowub) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void loadProblem(const CoinPackedMatrix& matrix,
                            const double* collb, const double* colub,
                            const double* obj,
                            const char* rowsen, const double* rowrhs,   
                            const double* rowrng) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void assignProblem(CoinPackedMatrix*& matrix,
                              double*& collb, double*& colub, double*& obj,
                              char*& rowsen, double*& rowrhs,
                              double*& rowrng) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void loadProblem(const int numcols, const int numrows,
                            const CoinBigIndex * start, const int* index,
                            const double* value,
                            const double* collb, const double* colub,   
                            const double* obj,
                            const double* rowlb, const double* rowub) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void loadProblem(const int numcols, const int numrows,
                            const CoinBigIndex * 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) {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }

   virtual void writeMps(const char *filename,
                         const char *extension = "mps",
                         double objSense=0.0) const {
      CoinAssertHint(0, "Sorry, not implemented yet.");
   }
   
   //-----------------------------------------------------------------------


   OsiNullSolverInterface() :
      OsiSolverInterface(),
      data_(NULL)
   {
      data_ = new OsiData(OsiNullInfinity);
   }
   
   virtual OsiNullSolverInterface * clone(bool copyData = true) const {
      CoinAssertHint(0, "Sorry, not implemented yet.");
      return NULL;
   }
  
   OsiNullSolverInterface(const OsiNullSolverInterface &);
  
   OsiNullSolverInterface & operator=(const OsiNullSolverInterface& rhs);
  
   virtual ~OsiNullSolverInterface () {
      delete data_;
   }


   //------------------------------------------------------------------------

protected:


   virtual void applyRowCut( const OsiRowCut & rc ) {
      CoinAssertHint(0, "OsiNull does not have a solver");
   }

   virtual void applyColCut( const OsiColCut & cc ) {
      CoinAssertHint(0, "OsiNull does not have a solver");
   }
   template <class T> inline T
   forceIntoRange(const T value, const T lower, const T upper) const {
      return value < lower ? lower : (value > upper ? upper : value);
   }
  
   //---------------------------------------------------------------------
protected:
   OsiData * data_;
};

#endif