/home/coin/SVN-release/Alps-1.2.0/Osi/src/Osi/OsiSolverInterface.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2000, International Business Machines
00002 // Corporation and others.  All Rights Reserved.
00003 #ifndef OsiSolverInterface_H
00004 #define OsiSolverInterface_H
00005 
00006 #include <string>
00007 #include <vector>
00008 
00009 #include "CoinMessageHandler.hpp"
00010 #include "CoinPackedVectorBase.hpp"
00011 
00012 #include "OsiCollections.hpp"
00013 #include "OsiSolverParameters.hpp"
00014 
00015 class CoinPackedMatrix;
00016 class CoinWarmStart;
00017 class CoinSnapshot;
00018 class CoinLpIO;
00019 class CoinMpsIO;
00020 
00021 class OsiCuts;
00022 class OsiAuxInfo;
00023 class OsiRowCut;
00024 class OsiRowCutDebugger;
00025 class CoinSet;
00026 class CoinBuild;
00027 class CoinModel;
00028 class OsiSolverBranch;
00029 class OsiSolverResult;
00030 class OsiObject;
00031 #include "CoinFinite.hpp"
00032 
00033 
00034 //#############################################################################
00035 
00057 class OsiSolverInterface  {
00058    friend int OsiSolverInterfaceCommonUnitTest(
00059       const OsiSolverInterface* emptySi,
00060       const std::string & mpsDir,
00061       const std::string & netlibDir);
00062    friend int OsiSolverInterfaceMpsUnitTest(
00063       const std::vector<OsiSolverInterface*> & vecSiP,
00064       const std::string & mpsDir);
00065 
00066 public:
00067 
00069   class ApplyCutsReturnCode {
00070     friend class OsiSolverInterface;
00071     friend class OsiOslSolverInterface;
00072     friend class OsiClpSolverInterface;
00073 
00074   public:
00076 
00077 
00078       ApplyCutsReturnCode():
00079          intInconsistent_(0),
00080          extInconsistent_(0),
00081          infeasible_(0),
00082          ineffective_(0),
00083          applied_(0) {} 
00085       ApplyCutsReturnCode(const ApplyCutsReturnCode & rhs):
00086          intInconsistent_(rhs.intInconsistent_),
00087          extInconsistent_(rhs.extInconsistent_),
00088          infeasible_(rhs.infeasible_),
00089          ineffective_(rhs.ineffective_),
00090          applied_(rhs.applied_) {} 
00092       ApplyCutsReturnCode & operator=(const ApplyCutsReturnCode& rhs)
00093       { 
00094         if (this != &rhs) { 
00095           intInconsistent_ = rhs.intInconsistent_;
00096           extInconsistent_ = rhs.extInconsistent_;
00097           infeasible_      = rhs.infeasible_;
00098           ineffective_     = rhs.ineffective_;
00099           applied_         = rhs.applied_;
00100         }
00101         return *this;
00102       }
00104       ~ApplyCutsReturnCode(){}
00106 
00109 
00110       inline int getNumInconsistent(){return intInconsistent_;}
00112       inline int getNumInconsistentWrtIntegerModel(){return extInconsistent_;}
00114       inline int getNumInfeasible(){return infeasible_;}
00116       inline int getNumIneffective(){return ineffective_;}
00118       inline int getNumApplied(){return applied_;}
00120 
00121   private: 
00124 
00125       inline void incrementInternallyInconsistent(){intInconsistent_++;}
00127       inline void incrementExternallyInconsistent(){extInconsistent_++;}
00129       inline void incrementInfeasible(){infeasible_++;}
00131       inline void incrementIneffective(){ineffective_++;}
00133       inline void incrementApplied(){applied_++;}
00135 
00137 
00138 
00139       int intInconsistent_;
00141       int extInconsistent_;
00143       int infeasible_;
00145       int ineffective_;
00147       int applied_;
00149   };
00150 
00151   //---------------------------------------------------------------------------
00152 
00154 
00155 
00156     virtual void initialSolve() = 0; 
00157 
00163     virtual void resolve() = 0;
00164 
00166     virtual void branchAndBound() = 0;
00167 
00168 #ifdef CBC_NEXT_VERSION
00169     /*
00170       Would it make sense to collect all of these routines in a `MIP Helper'
00171       section? It'd make it easier for users and implementors to find them.
00172     */
00190     virtual int solveBranches(int depth,const OsiSolverBranch * branch,
00191                               OsiSolverResult * result,
00192                               int & numberSolves, int & numberIterations,
00193                               bool forceBranch=false);
00194 #endif
00195 
00196 
00197   //---------------------------------------------------------------------------
00255 
00256     virtual bool setIntParam(OsiIntParam key, int value) {
00257       if (key == OsiLastIntParam) return (false) ;
00258       intParam_[key] = value;
00259       return true;
00260     }
00262     virtual bool setDblParam(OsiDblParam key, double value) {
00263       if (key == OsiLastDblParam) return (false) ;
00264       dblParam_[key] = value;
00265       return true;
00266     }
00268     virtual bool setStrParam(OsiStrParam key, const std::string & value) {
00269       if (key == OsiLastStrParam) return (false) ;
00270       strParam_[key] = value;
00271       return true;
00272     }
00284     virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
00285                               OsiHintStrength strength=OsiHintTry,
00286                               void *otherInformation = NULL) {
00287       if (key==OsiLastHintParam)
00288         return false; 
00289       hintParam_[key] = yesNo;
00290       hintStrength_[key] = strength;
00291       if (strength == OsiForceDo)
00292         throw CoinError("OsiForceDo illegal",
00293                         "setHintParam", "OsiSolverInterface");
00294       return true;
00295     }
00297     virtual bool getIntParam(OsiIntParam key, int& value) const {
00298       if (key == OsiLastIntParam) return (false) ;
00299       value = intParam_[key];
00300       return true;
00301     }
00303     virtual bool getDblParam(OsiDblParam key, double& value) const {
00304       if (key == OsiLastDblParam) return (false) ;
00305       value = dblParam_[key];
00306       return true;
00307     }
00309     virtual bool getStrParam(OsiStrParam key, std::string& value) const {
00310       if (key == OsiLastStrParam) return (false) ;
00311       value = strParam_[key];
00312       return true;
00313     }
00323     virtual bool getHintParam(OsiHintParam key, bool& yesNo,
00324                               OsiHintStrength& strength,
00325                               void *& otherInformation) const {
00326       if (key==OsiLastHintParam)
00327         return false; 
00328       yesNo = hintParam_[key];
00329       strength = hintStrength_[key];
00330       otherInformation=NULL;
00331       return true;
00332     }
00337     virtual bool getHintParam(OsiHintParam key, bool& yesNo,
00338                               OsiHintStrength& strength) const {
00339       if (key==OsiLastHintParam)
00340         return false; 
00341       yesNo = hintParam_[key];
00342       strength = hintStrength_[key];
00343       return true;
00344     }
00349     virtual bool getHintParam(OsiHintParam key, bool& yesNo) const {
00350       if (key==OsiLastHintParam)
00351         return false; 
00352       yesNo = hintParam_[key];
00353       return true;
00354     }
00361     void copyParameters(OsiSolverInterface & rhs);
00362 
00376     inline double getIntegerTolerance() const
00377     { return dblParam_[OsiPrimalTolerance];}
00379 
00380   //---------------------------------------------------------------------------
00382 
00383 
00384     virtual bool isAbandoned() const = 0;
00386     virtual bool isProvenOptimal() const = 0;
00388     virtual bool isProvenPrimalInfeasible() const = 0;
00390     virtual bool isProvenDualInfeasible() const = 0;
00392     virtual bool isPrimalObjectiveLimitReached() const = 0;
00394     virtual bool isDualObjectiveLimitReached() const = 0;
00396     virtual bool isIterationLimitReached() const = 0;
00398 
00399   //---------------------------------------------------------------------------
00417     virtual CoinWarmStart *getEmptyWarmStart () const = 0 ;
00418 
00425     virtual CoinWarmStart* getWarmStart() const = 0;
00434     virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;
00435 
00444     virtual bool setWarmStart(const CoinWarmStart* warmstart) = 0;
00446 
00447   //---------------------------------------------------------------------------
00468 
00469     virtual void markHotStart();
00471     virtual void solveFromHotStart();
00473     virtual void unmarkHotStart();
00475 
00476   //---------------------------------------------------------------------------
00487 
00488     virtual int getNumCols() const = 0;
00489 
00491     virtual int getNumRows() const = 0;
00492 
00494     virtual int getNumElements() const = 0;
00495 
00497     virtual int getNumIntegers() const ;
00498 
00500     virtual const double * getColLower() const = 0;
00501 
00503     virtual const double * getColUpper() const = 0;
00504 
00514     virtual const char * getRowSense() const = 0;
00515 
00528     virtual const double * getRightHandSide() const = 0;
00529 
00538     virtual const double * getRowRange() const = 0;
00539 
00541     virtual const double * getRowLower() const = 0;
00542 
00544     virtual const double * getRowUpper() const = 0;
00545 
00547     virtual const double * getObjCoefficients() const = 0;
00548 
00550     virtual double getObjSense() const = 0;
00551 
00553     virtual bool isContinuous(int colIndex) const = 0;
00554 
00556     virtual bool isBinary(int colIndex) const;
00557 
00562     virtual bool isInteger(int colIndex) const;
00563 
00565     virtual bool isIntegerNonBinary(int colIndex) const;
00566 
00568     virtual bool isFreeBinary(int colIndex) const; 
00575     inline const char * columnType(bool refresh=false) const
00576     { return getColType(refresh);}
00582     virtual const char * getColType(bool refresh=false) const;
00583   
00585     virtual const CoinPackedMatrix * getMatrixByRow() const = 0;
00586 
00588     virtual const CoinPackedMatrix * getMatrixByCol() const = 0;
00589 
00591     virtual CoinPackedMatrix * getMutableMatrixByRow() const {return NULL;}
00592 
00594     virtual CoinPackedMatrix * getMutableMatrixByCol() const {return NULL;}
00595 
00597     virtual double getInfinity() const = 0;
00599     
00602 
00603     virtual const double * getColSolution() const = 0;
00604 
00608     virtual const double * getStrictColSolution();
00609 
00611     virtual const double * getRowPrice() const = 0;
00612 
00614     virtual const double * getReducedCost() const = 0;
00615 
00621     virtual const double * getRowActivity() const = 0;
00622 
00624     virtual double getObjValue() const = 0;
00625 
00629     virtual int getIterationCount() const = 0;
00630 
00653     virtual std::vector<double*> getDualRays(int maxNumRays,
00654                                              bool fullRay = false) const = 0;
00655 
00671     virtual std::vector<double*> getPrimalRays(int maxNumRays) const = 0;
00672 
00675     virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
00676       const;
00678 
00679   //-------------------------------------------------------------------------
00692     virtual void setObjCoeff( int elementIndex, double elementValue ) = 0;
00693 
00695     virtual void setObjCoeffSet(const int* indexFirst,
00696                                 const int* indexLast,
00697                                 const double* coeffList);
00698 
00704     virtual void setObjective(const double * array);
00705 
00716     virtual void setObjSense(double s) = 0;
00717   
00718 
00721     virtual void setColLower( int elementIndex, double elementValue ) = 0;
00722     
00728     virtual void setColLower(const double * array);
00729 
00732     virtual void setColUpper( int elementIndex, double elementValue ) = 0;
00733 
00739     virtual void setColUpper(const double * array);
00740     
00741     
00745     virtual void setColBounds( int elementIndex,
00746                                double lower, double upper ) {
00747        setColLower(elementIndex, lower);
00748        setColUpper(elementIndex, upper);
00749     }
00750   
00757     virtual void setColSetBounds(const int* indexFirst,
00758                                  const int* indexLast,
00759                                  const double* boundList);
00760 
00763     virtual void setRowLower( int elementIndex, double elementValue ) = 0;
00764     
00767     virtual void setRowUpper( int elementIndex, double elementValue ) = 0;
00768   
00772     virtual void setRowBounds( int elementIndex,
00773                                double lower, double upper ) {
00774        setRowLower(elementIndex, lower);
00775        setRowUpper(elementIndex, upper);
00776     }
00777 
00784     virtual void setRowSetBounds(const int* indexFirst,
00785                                  const int* indexLast,
00786                                  const double* boundList);
00787   
00788   
00790     virtual void setRowType(int index, char sense, double rightHandSide,
00791                             double range) = 0;
00792   
00797     virtual void setRowSetTypes(const int* indexFirst,
00798                                 const int* indexLast,
00799                                 const char* senseList,
00800                                 const double* rhsList,
00801                                 const double* rangeList);
00802 
00812     virtual void setColSolution(const double *colsol) = 0;
00813 
00823     virtual void setRowPrice(const double * rowprice) = 0;
00824 
00833     virtual int reducedCostFix(double gap, bool justInteger=true);
00835 
00836   //-------------------------------------------------------------------------
00840     virtual void setContinuous(int index) = 0;
00842     virtual void setInteger(int index) = 0;
00845     virtual void setContinuous(const int* indices, int len);
00848     virtual void setInteger(const int* indices, int len);
00850   //-------------------------------------------------------------------------
00851 
00852   //-------------------------------------------------------------------------
00853 
00855     typedef std::vector<std::string> OsiNameVec ;
00856 
00877 
00887     virtual std::string dfltRowColName(char rc,
00888                                  int ndx, unsigned digits = 7) const ;
00889 
00892   virtual std::string getObjName (unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ;
00893 
00896     virtual inline void setObjName (std::string name)
00897     { objName_ = name ; }
00898 
00905     virtual std::string getRowName(int rowIndex,
00906                                    unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ;
00907 
00919     virtual const OsiNameVec &getRowNames() ;
00920 
00926     virtual void setRowName(int ndx, std::string name) ;
00927 
00934     virtual void setRowNames(OsiNameVec &srcNames,
00935                      int srcStart, int len, int tgtStart) ;
00936 
00942     virtual void deleteRowNames(int tgtStart, int len) ;
00943   
00950     virtual std::string getColName(int colIndex,
00951                                    unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ;
00952 
00962     virtual const OsiNameVec &getColNames() ;
00963 
00969     virtual void setColName(int ndx, std::string name) ;
00970 
00977     virtual void setColNames(OsiNameVec &srcNames,
00978                      int srcStart, int len, int tgtStart) ;
00979 
00985     virtual void deleteColNames(int tgtStart, int len) ;
00986   
00987 
00994     void setRowColNames(const CoinMpsIO &mps) ;
00995 
01001     void setRowColNames(CoinModel &mod) ;
01002 
01009     void setRowColNames(CoinLpIO &mod) ;
01010 
01012   //-------------------------------------------------------------------------
01013     
01014   //-------------------------------------------------------------------------
01020 
01022     virtual void addCol(const CoinPackedVectorBase& vec,
01023                         const double collb, const double colub,   
01024                         const double obj) = 0;
01025 
01031     virtual void addCol(const CoinPackedVectorBase& vec,
01032                         const double collb, const double colub,   
01033                         const double obj, std::string name) ;
01034 
01036     virtual void addCol(int numberElements,
01037                         const int* rows, const double* elements,
01038                         const double collb, const double colub,   
01039                         const double obj) ;
01040 
01046     virtual void addCol(int numberElements,
01047                         const int* rows, const double* elements,
01048                         const double collb, const double colub,   
01049                         const double obj, std::string name) ;
01050 
01056     virtual void addCols(const int numcols,
01057                          const CoinPackedVectorBase * const * cols,
01058                          const double* collb, const double* colub,   
01059                          const double* obj);
01060 
01066     virtual void addCols(const int numcols, const int* columnStarts,
01067                          const int* rows, const double* elements,
01068                          const double* collb, const double* colub,   
01069                          const double* obj);
01070 
01072     void addCols(const CoinBuild & buildObject);
01073 
01079     int addCols(CoinModel & modelObject);
01080 
01081 #if 0
01082 
01083     virtual void addCols(const CoinPackedMatrix& matrix,
01084                          const double* collb, const double* colub,   
01085                          const double* obj);
01086 #endif
01087 
01094     virtual void deleteCols(const int num, const int * colIndices) = 0;
01095   
01097     virtual void addRow(const CoinPackedVectorBase& vec,
01098                         const double rowlb, const double rowub) = 0;
01099 
01105     virtual void addRow(const CoinPackedVectorBase& vec,
01106                         const double rowlb, const double rowub,
01107                         std::string name) ;
01108 
01110     virtual void addRow(const CoinPackedVectorBase& vec,
01111                         const char rowsen, const double rowrhs,   
01112                         const double rowrng) = 0;
01113 
01119     virtual void addRow(const CoinPackedVectorBase& vec,
01120                         const char rowsen, const double rowrhs,   
01121                         const double rowrng, std::string name) ;
01122 
01127     virtual void addRow(int numberElements,
01128                         const int *columns, const double *element,
01129                         const double rowlb, const double rowub) ;
01130 
01136     virtual void addRows(const int numrows,
01137                          const CoinPackedVectorBase * const * rows,
01138                          const double* rowlb, const double* rowub);
01139 
01145     virtual void addRows(const int numrows,
01146                          const CoinPackedVectorBase * const * rows,
01147                          const char* rowsen, const double* rowrhs,   
01148                          const double* rowrng);
01149 
01155     virtual void addRows(const int numrows, const int *rowStarts,
01156                          const int *columns, const double *element,
01157                          const double *rowlb, const double *rowub);
01158 
01160     void addRows(const CoinBuild &buildObject);
01161 
01170     int addRows(CoinModel &modelObject);
01171 
01172 #if 0
01173 
01174     virtual void addRows(const CoinPackedMatrix& matrix,
01175                          const double* rowlb, const double* rowub);
01177     virtual void addRows(const CoinPackedMatrix& matrix,
01178                          const char* rowsen, const double* rowrhs,   
01179                          const double* rowrng);
01180 #endif
01181 
01187     virtual void deleteRows(const int num, const int * rowIndices) = 0;
01188 
01195     virtual void replaceMatrixOptional(const CoinPackedMatrix & ) {}
01196 
01201     virtual void replaceMatrix(const CoinPackedMatrix & ) {abort();}
01202 
01207     virtual void saveBaseModel() {}
01208 
01222     virtual void restoreBaseModel(int numberRows);
01223     //-----------------------------------------------------------------------
01246     virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
01247                                           double effectivenessLb = 0.0);
01248 
01253     virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
01254 
01258     virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
01259 
01261     void deleteBranchingInfo(int numberDeleted, const int * which);
01262 
01264 
01265   //---------------------------------------------------------------------------
01266 
01284     virtual void loadProblem (const CoinPackedMatrix& matrix,
01285                               const double* collb, const double* colub,   
01286                               const double* obj,
01287                               const double* rowlb, const double* rowub) = 0;
01288                             
01298     virtual void assignProblem (CoinPackedMatrix*& matrix,
01299                                 double*& collb, double*& colub, double*& obj,
01300                                 double*& rowlb, double*& rowub) = 0;
01301 
01318     virtual void loadProblem (const CoinPackedMatrix& matrix,
01319                               const double* collb, const double* colub,
01320                               const double* obj,
01321                               const char* rowsen, const double* rowrhs,   
01322                               const double* rowrng) = 0;
01323 
01333     virtual void assignProblem (CoinPackedMatrix*& matrix,
01334                                 double*& collb, double*& colub, double*& obj,
01335                                 char*& rowsen, double*& rowrhs,
01336                                 double*& rowrng) = 0;
01337 
01350     virtual void loadProblem (const int numcols, const int numrows,
01351                               const CoinBigIndex * start, const int* index,
01352                               const double* value,
01353                               const double* collb, const double* colub,   
01354                               const double* obj,
01355                               const double* rowlb, const double* rowub) = 0;
01356 
01369     virtual void loadProblem (const int numcols, const int numrows,
01370                               const CoinBigIndex * start, const int* index,
01371                               const double* value,
01372                               const double* collb, const double* colub,   
01373                               const double* obj,
01374                               const char* rowsen, const double* rowrhs,   
01375                               const double* rowrng) = 0;
01376 
01383     virtual int loadFromCoinModel (CoinModel & modelObject,
01384                                    bool keepSolution=false);
01385 
01391     virtual int readMps (const char *filename,
01392                          const char *extension = "mps") ;
01393 
01400     virtual int readMps (const char *filename, const char*extension,
01401                         int & numberSets, CoinSet ** & sets);
01402 
01408     virtual int readGMPL (const char *filename, const char *dataname=NULL);
01409 
01416     virtual void writeMps (const char *filename,
01417                            const char *extension = "mps",
01418                            double objSense=0.0) const = 0;
01419 
01433     int writeMpsNative (const char *filename, 
01434                         const char ** rowNames, const char ** columnNames,
01435                         int formatType=0,int numberAcross=2,
01436                         double objSense=0.0, int numberSOS=0,
01437                         const CoinSet * setInfo=NULL) const ;
01438 
01439 /***********************************************************************/
01440 // Lp files 
01441 
01461   virtual void writeLp(const char *filename,
01462                const char *extension = "lp",
01463                 double epsilon = 1e-5,
01464                 int numberAcross = 10,
01465                 int decimals = 5,
01466                 double objSense = 0.0,
01467                 bool useRowNames = true) const;
01468 
01473   virtual void writeLp(FILE *fp,
01474                 double epsilon = 1e-5,
01475                 int numberAcross = 10,
01476                 int decimals = 5,
01477                 double objSense = 0.0,
01478                 bool useRowNames = true) const;
01479 
01498   int writeLpNative(const char *filename,
01499                     char const * const * const rowNames,
01500                     char const * const * const columnNames,
01501                     const double epsilon = 1.0e-5,
01502                     const int numberAcross = 10,
01503                     const int decimals = 5,
01504                     const double objSense = 0.0,
01505                     const bool useRowNames = true) const;
01506 
01511   int writeLpNative(FILE *fp,
01512                     char const * const * const rowNames,
01513                     char const * const * const columnNames,
01514                     const double epsilon = 1.0e-5,
01515                     const int numberAcross = 10,
01516                     const int decimals = 5,
01517                     const double objSense = 0.0,
01518                     const bool useRowNames = true) const;
01519 
01522   virtual int readLp(const char *filename, const double epsilon = 1e-5);
01523 
01526   int readLp(FILE *fp, const double epsilon = 1e-5);
01527 
01529 
01530   //---------------------------------------------------------------------------
01531 
01534 #ifdef COIN_SNAPSHOT
01536   virtual CoinSnapshot * snapshot(bool createArrays=true) const;
01537 #endif
01538 #ifdef COIN_FACTORIZATION_INFO
01540   virtual CoinBigIndex getSizeL() const;
01542   virtual CoinBigIndex getSizeU() const;
01543 #endif
01544 
01545 
01546   //---------------------------------------------------------------------------
01547 
01557     void setApplicationData (void * appData);
01564     void setAuxiliaryInfo(OsiAuxInfo * auxiliaryInfo);
01565 
01567     void * getApplicationData() const;
01569     OsiAuxInfo * getAuxiliaryInfo() const;
01571   //---------------------------------------------------------------------------
01572 
01586   virtual void passInMessageHandler(CoinMessageHandler * handler);
01588   void newLanguage(CoinMessages::Language language);
01589   inline void setLanguage(CoinMessages::Language language)
01590   {newLanguage(language);}
01592   inline CoinMessageHandler * messageHandler() const
01593   {return handler_;}
01595   inline CoinMessages messages() 
01596   {return messages_;}
01598   inline CoinMessages * messagesPointer() 
01599   {return &messages_;}
01601   inline bool defaultHandler() const
01602   { return defaultHandler_;}
01604   //---------------------------------------------------------------------------
01619     void findIntegers(bool justCount);
01630     virtual int findIntegersAndSOS(bool justCount);
01632     inline int numberObjects() const { return numberObjects_;}
01634     inline void setNumberObjects(int number) 
01635     {  numberObjects_=number;}
01636 
01638     inline OsiObject ** objects() const { return object_;}
01639 
01641     const inline OsiObject * object(int which) const { return object_[which];}
01643     inline OsiObject * modifiableObject(int which) const { return object_[which];}
01644 
01646     void deleteObjects();
01647 
01652     void addObjects(int numberObjects, OsiObject ** objects);
01657     double forceFeasible();
01659   //---------------------------------------------------------------------------
01660 
01669     virtual void activateRowCutDebugger (const char * modelName);
01670 
01676     virtual void activateRowCutDebugger( const double * solution);
01686     const OsiRowCutDebugger * getRowCutDebugger() const;
01688     const OsiRowCutDebugger * getRowCutDebuggerAlways() const;
01689 
01691   
01700 
01711   virtual int canDoSimplexInterface() const ;
01713 
01721 
01730   virtual void enableFactorization() const ;
01731 
01733   virtual void disableFactorization() const ;
01734 
01745   virtual bool basisIsAvailable() const ;
01746 
01748   inline bool optimalBasisIsAvailable() const { return basisIsAvailable() ; }
01749 
01773   virtual void getBasisStatus(int* cstat, int* rstat) const ;
01774 
01789   virtual int setBasisStatus(const int* cstat, const int* rstat) ;
01790 
01796   virtual void getReducedGradient(double* columnReducedCosts, 
01797                                   double* duals, const double* c) const ;
01798 
01804   virtual void getBInvARow(int row, double* z, double* slack = NULL) const ;
01805 
01807   virtual void getBInvRow(int row, double* z) const ;
01808 
01810   virtual void getBInvACol(int col, double* vec) const ;
01811 
01813   virtual void getBInvCol(int col, double* vec) const ;
01814 
01822   virtual void getBasics(int* index) const ;
01823 
01825 
01833 
01840   virtual void enableSimplexInterface(bool doingPrimal) ;
01841 
01843   virtual void disableSimplexInterface() ;
01851   virtual int pivot(int colIn, int colOut, int outStatus) ;
01852 
01864   virtual int primalPivotResult(int colIn, int sign, 
01865                                 int& colOut, int& outStatus, 
01866                                 double& t, CoinPackedVector* dx);
01867 
01874   virtual int dualPivotResult(int& colIn, int& sign, 
01875                               int colOut, int outStatus, 
01876                               double& t, CoinPackedVector* dx) ;
01878    
01879   //---------------------------------------------------------------------------
01880 
01882 
01883 
01884     OsiSolverInterface(); 
01885     
01891     virtual OsiSolverInterface * clone(bool copyData = true) const = 0;
01892   
01894     OsiSolverInterface(const OsiSolverInterface &);
01895   
01897     OsiSolverInterface & operator=(const OsiSolverInterface& rhs);
01898   
01900     virtual ~OsiSolverInterface ();
01901 
01908     virtual void reset();
01910 
01911   //---------------------------------------------------------------------------
01912 
01913 protected:
01915 
01916 
01917     virtual void applyRowCut( const OsiRowCut & rc ) = 0;
01918 
01920     virtual void applyColCut( const OsiColCut & cc ) = 0;
01921 
01924     inline void
01925     convertBoundToSense(const double lower, const double upper,
01926                         char& sense, double& right, double& range) const;
01929     inline void
01930     convertSenseToBound(const char sense, const double right,
01931                         const double range,
01932                         double& lower, double& upper) const;
01935     template <class T> inline T
01936     forceIntoRange(const T value, const T lower, const T upper) const {
01937       return value < lower ? lower : (value > upper ? upper : value);
01938     }
01945     void setInitialData();
01947 
01949 
01950 
01951     OsiRowCutDebugger * rowCutDebugger_;
01952    // Why not just make useful stuff protected?
01954   CoinMessageHandler * handler_;
01960   bool defaultHandler_;
01962   CoinMessages messages_;
01964   int numberIntegers_;
01966   int numberObjects_;
01967 
01969   OsiObject ** object_;
01975   mutable char * columnType_;
01976 
01978   
01979   //---------------------------------------------------------------------------
01980 
01981 private:
01983 
01984 
01985     OsiAuxInfo * appDataEtc_;
01987     int intParam_[OsiLastIntParam];
01989     double dblParam_[OsiLastDblParam];
01991     std::string strParam_[OsiLastStrParam];
01993     bool hintParam_[OsiLastHintParam];
01995     OsiHintStrength hintStrength_[OsiLastHintParam];
01998     CoinWarmStart* ws_;
02000     std::vector<double> strictColSolution_;
02001 
02003     OsiNameVec rowNames_ ;
02005     OsiNameVec colNames_ ;
02007     std::string objName_ ;
02008 
02010 };
02011 
02012 //#############################################################################
02020 int
02021 OsiSolverInterfaceCommonUnitTest(
02022    const OsiSolverInterface* emptySi,
02023    const std::string & mpsDir,
02024    const std::string & netlibDir);
02025 
02026 //#############################################################################
02029 int
02030 OsiSolverInterfaceMpsUnitTest(
02031    const std::vector<OsiSolverInterface*> & vecSiP,
02032    const std::string & mpsDir);
02033 
02034 //#############################################################################
02037 inline void
02038 OsiSolverInterface::convertBoundToSense(const double lower, const double upper,
02039                                         char& sense, double& right,
02040                                         double& range) const
02041 {
02042   double inf = getInfinity();
02043   range = 0.0;
02044   if (lower > -inf) {
02045     if (upper < inf) {
02046       right = upper;
02047       if (upper==lower) {
02048         sense = 'E';
02049       } else {
02050         sense = 'R';
02051         range = upper - lower;
02052       }
02053     } else {
02054       sense = 'G';
02055       right = lower;
02056     }
02057   } else {
02058     if (upper < inf) {
02059       sense = 'L';
02060       right = upper;
02061     } else {
02062       sense = 'N';
02063       right = 0.0;
02064     }
02065   }
02066 }
02067 
02068 //-----------------------------------------------------------------------------
02071 inline void
02072 OsiSolverInterface::convertSenseToBound(const char sense, const double right,
02073                                         const double range,
02074                                         double& lower, double& upper) const
02075 {
02076   double inf=getInfinity();
02077   switch (sense) {
02078   case 'E':
02079     lower = upper = right;
02080     break;
02081   case 'L':
02082     lower = -inf;
02083     upper = right;
02084     break;
02085   case 'G':
02086     lower = right;
02087     upper = inf;
02088     break;
02089   case 'R':
02090     lower = right - range;
02091     upper = right;
02092     break;
02093   case 'N':
02094     lower = -inf;
02095     upper = inf;
02096     break;
02097   }
02098 }
02099 
02100 #endif

Generated on Fri Nov 5 03:05:39 2010 by  doxygen 1.4.7