/home/coin/SVN-release/CoinAll-1.1.0/Osi/src/OsiSym/OsiSymSolverInterface.hpp

Go to the documentation of this file.

/*===========================================================================*/
/*                                                                           */
/* This file is part of the SYMPHONY Branch, Cut, and Price Callable         */
/* Library.                                                                  */
/*                                                                           */
/* SYMPHONY was jointly developed by Ted Ralphs (tkralphs@lehigh.edu) and    */
/* Laci Ladanyi (ladanyi@us.ibm.com).                                        */
/*                                                                           */
/* (c) Copyright 2004-2006 Ted Ralphs and Lehigh University.                 */
/* All Rights Reserved.                                                      */
/*                                                                           */
/* The authors of this file are Menal Guzelsoy and Ted Ralphs                */
/*                                                                           */
/* This software is licensed under the Common Public License. Please see     */
/* accompanying file for terms.                                              */
/*                                                                           */
/*===========================================================================*/

#ifndef OsiSymSolverInterface_hpp
#define OsiSymSolverInterface_hpp

#include "OsiSolverInterface.hpp"
#include "OsiSymSolverParameters.hpp"
#include "SymWarmStart.hpp"
#include "symphony.h"

#include "CoinPackedVector.hpp"
#include "CoinPackedMatrix.hpp"

#include <iostream>
#include <string>
#include <cassert>

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

class OsiSymSolverInterface : virtual public OsiSolverInterface {
   friend void OsiSymSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
   
public:


   virtual void initialSolve();

   virtual void resolve();

   virtual void branchAndBound();
   
   virtual void multiCriteriaBranchAndBound();

   virtual double getLbForNewRhs(int cnt, int *index, 
                                 double * value);
   virtual double getUbForNewRhs(int cnt, int *index, 
                                 double * value);
#if 0
   virtual double getLbForNewObj(int cnt, int *index, 
                                 double * value);
#endif
   virtual double getUbForNewObj(int cnt, int *index, 
                                 double * value);


  //---------------------------------------------------------------------------
    // Set an integer parameter
    virtual bool setIntParam(OsiIntParam key, int value);

    // Set SYMPHONY int parameter
    virtual bool setSymParam(OsiSymIntParam key, int value);

    // Set SYMPHONY int parameter directly by the C interface parameter name
    virtual bool setSymParam(const std::string key, int value);


    // Set an double parameter
    virtual bool setDblParam(OsiDblParam key, double value);

    // Set SYMPHONY double parameter
    virtual bool setSymParam(OsiSymDblParam key, double value);

    // Set SYMPHONY double parameter directly by the C interface parameter name
    virtual bool setSymParam(const std::string key, double value);



    // Set a string parameter
    virtual bool setStrParam(OsiStrParam key, const std::string & value);

    // Set SYMPHONY string parameter
    virtual bool setSymParam(OsiSymStrParam key, const std::string & value);

    // Set SYMPHONY string parameter directly by the C interface parameter name
    virtual bool setSymParam(const std::string key, const std::string value);



    // Get an integer parameter
    virtual bool getIntParam(OsiIntParam key, int& value) const;

    // Get SYMPHONY int parameter
    virtual bool getSymParam(OsiSymIntParam key, int& value) const;

    // Get SYMPHONY int parameter directly by the C interface parameter name
    virtual bool getSymParam(const std::string key, int& value) const;


    // Get an double parameter
    virtual bool getDblParam(OsiDblParam key, double& value) const;

    // Get SYMPHONY double parameter
    virtual bool getSymParam(OsiSymDblParam key, double& value) const;

    // Get SYMPHONY double parameter directly by the C interface parameter name
    virtual bool getSymParam(const std::string key, double& value) const;



    // Get a string parameter
    virtual bool getStrParam(OsiStrParam key, std::string& value) const;

    // Get SYMPHONY string parameter
    virtual bool getSymParam(OsiSymStrParam key, std::string& value) const;

    // Get SYMPHONY string parameter directly by the C interface parameter name
    virtual bool getSymParam(const std::string key, std::string& value) const;


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


   virtual bool isAbandoned() const;

   virtual bool isProvenOptimal() const;

   virtual bool isProvenPrimalInfeasible() const;

   virtual bool isProvenDualInfeasible() const {
      throw CoinError("Error: Function not implemented",
                      "isProvenDualInfeasible", "OsiSymSolverInterface");
   }
   virtual bool isPrimalObjectiveLimitReached() const;

    virtual bool isDualObjectiveLimitReached() const{
       throw CoinError("Error: Function not implemented",
                       "isDualObjectiveLimitReached", "OsiSymSolverInterface");
    }
   virtual bool isIterationLimitReached() const;

   virtual bool isTimeLimitReached() const;

   virtual bool isTargetGapReached() const;


  //---------------------------------------------------------------------------
    virtual CoinWarmStart *getEmptyWarmStart () const{
       throw CoinError("Error: Function not implemented",
                       "getEmptyWarmStart", "OsiSymSolverInterface");
    }

   /* 
      virtual CoinWarmStart* getWarmStart(bool keepTreeInSymEnv = false) const;
   */

    virtual CoinWarmStart* getWarmStart() const;

   virtual bool setWarmStart(const CoinWarmStart* warmstart);
   
  //---------------------------------------------------------------------------

   sym_environment *getSymphonyEnvironment() const {return env_;}
   
   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 const double * getObj2Coefficients() const;

   virtual double getObjSense() const; 
 
   virtual bool isContinuous(int colIndex) const;
  
   virtual bool isBinary(int colIndex) const;  

   virtual bool isInteger(int colIndex) const;
  
   virtual bool isIntegerNonBinary(int colIndex) const;
  
   virtual bool isFreeBinary(int colIndex) const; 
   
   virtual const CoinPackedMatrix * getMatrixByRow() const;
  
   virtual const CoinPackedMatrix * getMatrixByCol() const;  

      virtual double getInfinity() const;

    

   virtual const double * getColSolution() const;
  
      virtual const double * getRowPrice() const{
         //       throw CoinError("Error: Function not implemented",
         //       "getRowPrice", "OsiSymSolverInterface");
         return (0);
    }
  
      virtual const double * getReducedCost() const{
         //       throw CoinError("Error: Function not implemented",
         //       "getReducedCost", "OsiSymSolverInterface");
         return (0);
    }
  
   virtual const double * getRowActivity() const;
  
   virtual double getObjValue() const;

   virtual double getPrimalBound() const;

   virtual int getIterationCount() const;
  
      virtual std::vector<double*> getDualRays(int maxNumRays) const{
       throw CoinError("Error: Function not implemented",
                       "getDualRays", "OsiSymSolverInterface");
    }
      virtual std::vector<double*> getPrimalRays(int maxNumRays) const{
       throw CoinError("Error: Function not implemented",
                       "getPrimalRays", "OsiSymSolverInterface");
    }
  

    //-------------------------------------------------------------------------
   virtual void setObjCoeff( int elementIndex, double elementValue );

   virtual void setObj2Coeff( int elementIndex, double elementValue );

   using OsiSolverInterface::setColLower ;
   virtual void setColLower( int elementIndex, double elementValue );
      
   using OsiSolverInterface::setColUpper ;
   virtual void setColUpper( int elementIndex, double elementValue );      

   virtual void setRowLower( int elementIndex, double elementValue );
      
   virtual void setRowUpper( int elementIndex, double elementValue );
    
      virtual void setRowType(int index, char sense, double rightHandSide,
                              double range);
    
   virtual void setObjSense(double s);
    
   virtual void setColSolution(const double *colsol);
   
   virtual void setPrimalBound(const double bound);

   virtual void setRowPrice(const double * rowprice){
       throw CoinError("Error: Function not implemented",
                       "setRowPrice", "OsiSymSolverInterface");
    }


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

      using OsiSolverInterface::setContinuous ;
   virtual void setContinuous(int index);

      using OsiSolverInterface::setInteger ;
   virtual void setInteger(int index);


      using OsiSolverInterface::setColName ;
   virtual void setColName(char **colname);

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

      using OsiSolverInterface::addCol ;
      virtual void addCol(const CoinPackedVectorBase& vec,
                          const double collb, const double colub,   
                          const double obj);

   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);
   
   virtual void deleteRows(const int num, const int * rowIndices);
    

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


    virtual void loadProblem();
   
    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 CoinBigIndex * 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 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);

    virtual void writeMps(const char *filename,
                          const char *extension = "mps",
                          double objSense=0.0) const;

   void parseCommandLine(int argc, char **argv);

   using OsiSolverInterface::readMps ;
   virtual int readMps(const char * infile, const char *extension = "mps");

   virtual int readGMPL(const char * modelFile, const char * dataFile=NULL);

   void findInitialBounds();

   int createPermanentCutPools();


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

   enum keepCachedFlag {
      KEEPCACHED_NONE    = 0,
      KEEPCACHED_COLUMN  = 1,
      KEEPCACHED_ROW     = 2,
      KEEPCACHED_MATRIX  = 4,
      KEEPCACHED_RESULTS = 8,
      KEEPCACHED_PROBLEM = KEEPCACHED_COLUMN | KEEPCACHED_ROW | KEEPCACHED_MATRIX,
      KEEPCACHED_ALL     = KEEPCACHED_PROBLEM | KEEPCACHED_RESULTS,
      FREECACHED_COLUMN  = KEEPCACHED_PROBLEM & !KEEPCACHED_COLUMN,
      FREECACHED_ROW     = KEEPCACHED_PROBLEM & !KEEPCACHED_ROW,
      FREECACHED_MATRIX  = KEEPCACHED_PROBLEM & !KEEPCACHED_MATRIX,
      FREECACHED_RESULTS = KEEPCACHED_ALL & !KEEPCACHED_RESULTS
   };
   


    OsiSymSolverInterface(); 
    
   virtual OsiSolverInterface * clone(bool copyData = true) const;
  
    OsiSymSolverInterface(const OsiSymSolverInterface &);
  
    OsiSymSolverInterface & operator=(const OsiSymSolverInterface& rhs);
  
    virtual ~OsiSymSolverInterface ();

    virtual void reset();

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

protected:


   virtual void applyRowCut( const OsiRowCut & rc );

   virtual void applyColCut( const OsiColCut & cc );

    void setInitialData();

private:

  void gutsOfConstructor();
  
  void gutsOfDestructor();

  void freeCachedColRim();

  void freeCachedRowRim();

  void freeCachedResults();
  
  void freeCachedMatrix();

  void freeCachedData( int keepCached = KEEPCACHED_NONE );

  void freeAllMemory();

  void printBounds(); 


   sym_environment *env_;
   
   mutable double  *obj_;

   mutable double  *obj2_;
   
   mutable double  *collower_;
   
   mutable double  *colupper_;
   
   mutable char    *rowsense_;
  
   mutable double  *rhs_;
  
   mutable double  *rowrange_;
   
   mutable double  *rowlower_;
   
   mutable double  *rowupper_;
   
   mutable double  *colsol_;
   
   mutable double  *rowact_;
   
   mutable CoinPackedMatrix *matrixByRow_;  
   
   mutable CoinPackedMatrix *matrixByCol_;  

};

//#############################################################################
void OsiSymSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);

#endif

---