Doxygen/CHiPPS-Alps/_osi_clp_solver_interface_8hpp_source.html

 // $Id$

 // Copyright (C) 2000, International Business Machines

 // Corporation and others.  All Rights Reserved.

 // This code is licensed under the terms of the Eclipse Public License (EPL).


 #ifndef OsiClpSolverInterface_H

 #define OsiClpSolverInterface_H


 #include <string>

 #include <cfloat>

 #include <map>


 #include "ClpSimplex.hpp"

 #include "ClpLinearObjective.hpp"

 #include "CoinPackedMatrix.hpp"

 #include "OsiSolverInterface.hpp"

 #include "CoinWarmStartBasis.hpp"

 #include "ClpEventHandler.hpp"

 #include "ClpNode.hpp"

 #include "CoinIndexedVector.hpp"

 #include "CoinFinite.hpp"


 class OsiRowCut;

 class OsiClpUserSolver;

 class OsiClpDisasterHandler;

 class CoinSet;

 static const double OsiClpInfinity = COIN_DBL_MAX;


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


 class OsiClpSolverInterface :

   virtual public OsiSolverInterface {

   friend void OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);


 public:

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

   virtual void initialSolve();


   virtual void resolve();


   virtual void resolveGub(int needed);


   virtual void branchAndBound();


   void crossover(int options,int basis);


   virtual int canDoSimplexInterface() const;


   virtual void enableFactorization() const;


   virtual void disableFactorization() const;


   virtual bool basisIsAvailable() const;


   virtual void getBasisStatus(int* cstat, int* rstat) const;


   virtual int setBasisStatus(const int* cstat, const int* rstat);


   virtual void getReducedGradient(double* columnReducedCosts,

                                   double * duals,

                                   const double * c) const ;


   virtual void getBInvARow(int row, double* z, double * slack=NULL) const;


   virtual void getBInvARow(int row, CoinIndexedVector * z, CoinIndexedVector * slack=NULL,

                            bool keepScaled=false) const;


   virtual void getBInvRow(int row, double* z) const;


   virtual void getBInvACol(int col, double* vec) const ;


   virtual void getBInvACol(int col, CoinIndexedVector * vec) const ;


   virtual void getBInvACol(CoinIndexedVector * vec) const ;


   virtual void getBInvCol(int col, double* vec) const ;


   virtual void getBasics(int* index) const;


   virtual void enableSimplexInterface(bool doingPrimal);

   void copyEnabledSuff(OsiClpSolverInterface & rhs);


   virtual void disableSimplexInterface();

   void copyEnabledStuff(ClpSimplex & rhs);


   virtual int pivot(int colIn, int colOut, int outStatus);


   virtual int primalPivotResult(int colIn, int sign,

                                 int& colOut, int& outStatus,

                                 double& t, CoinPackedVector* dx);


   virtual int dualPivotResult(int& colIn, int& sign,

                               int colOut, int outStatus,

                               double& t, CoinPackedVector* dx);


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

   // 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;

   // Set a hint parameter - overrides OsiSolverInterface

   virtual bool setHintParam(OsiHintParam key, bool yesNo=true,

                             OsiHintStrength strength=OsiHintTry,

                             void * otherInformation=NULL);


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


   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;

   inline CoinWarmStartBasis* getPointerToWarmStart()

   { return &basis_;}

   inline const CoinWarmStartBasis* getConstPointerToWarmStart() const

   { return &basis_;}

   virtual bool setWarmStart(const CoinWarmStart* warmstart);

   virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;


   void setColumnStatus(int iColumn, ClpSimplex::Status status);


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

   virtual void markHotStart();

   virtual void solveFromHotStart();

   virtual void unmarkHotStart();

   int startFastDual(int options);

   void stopFastDual();

   void setStuff(double tolerance,double increment);

   OsiRowCut * smallModelCut(const double * originalLower, const double * originalUpper,

                             int numberRowsAtContinuous,const int * whichGenerator,

                             int typeCut=0);

   OsiRowCut * modelCut(const double * originalLower, const double * originalUpper,

                        int numberRowsAtContinuous,const int * whichGenerator,

                        int typeCut=0);


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

   virtual int getNumCols() const {

     return modelPtr_->numberColumns(); }


   virtual int getNumRows() const {

     return modelPtr_->numberRows(); }


   virtual int getNumElements() const {

     int retVal = 0;

     const CoinPackedMatrix * matrix =modelPtr_->matrix();

     if ( matrix != NULL ) retVal=matrix->getNumElements();

     return retVal; }


     virtual std::string getRowName(int rowIndex,

                                    unsigned maxLen = static_cast<unsigned>(std::string::npos)) const;


     virtual std::string getColName(int colIndex,

                                    unsigned maxLen = static_cast<unsigned>(std::string::npos)) const;


   virtual const double * getColLower() const { return modelPtr_->columnLower(); }


   virtual const double * getColUpper() const { return modelPtr_->columnUpper(); }


   virtual const char * getRowSense() const;


   virtual const double * getRightHandSide() const ;


   virtual const double * getRowRange() const ;


   virtual const double * getRowLower() const { return modelPtr_->rowLower(); }


   virtual const double * getRowUpper() const { return modelPtr_->rowUpper(); }


   virtual const double * getObjCoefficients() const

   { if (fakeMinInSimplex_)

       return linearObjective_ ;

     else

       return modelPtr_->objective(); }


   virtual double getObjSense() const

   { return ((fakeMinInSimplex_)?-modelPtr_->optimizationDirection():

                                  modelPtr_->optimizationDirection()); }


   virtual bool isContinuous(int colNumber) 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 char * getColType(bool refresh=false) const;


   bool isOptionalInteger(int colIndex) const;

   void setOptionalInteger(int index);


   virtual const CoinPackedMatrix * getMatrixByRow() const;


   virtual const CoinPackedMatrix * getMatrixByCol() const;


   virtual CoinPackedMatrix * getMutableMatrixByCol() const;


   virtual double getInfinity() const { return OsiClpInfinity; }


   virtual const double * getColSolution() const;


   virtual const double * getRowPrice() const;


   virtual const double * getReducedCost() const;


   virtual const double * getRowActivity() const;


   virtual double getObjValue() const;


   virtual int getIterationCount() const

   { return modelPtr_->numberIterations(); }


   virtual std::vector<double*> getDualRays(int maxNumRays,

                                            bool fullRay = false) const;

   virtual std::vector<double*> getPrimalRays(int maxNumRays) const;


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


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

   virtual void setObjCoeff( int elementIndex, double elementValue );


   virtual void setColLower( int elementIndex, double elementValue );


   virtual void setColUpper( int elementIndex, double elementValue );


   virtual void setColBounds( int elementIndex,

                              double lower, double upper );


   virtual void setColSetBounds(const int* indexFirst,

                                const int* indexLast,

                                const double* boundList);


   virtual void setRowLower( int elementIndex, double elementValue );


   virtual void setRowUpper( int elementIndex, double elementValue ) ;


   virtual void setRowBounds( int elementIndex,

                              double lower, double upper ) ;


   virtual void setRowType(int index, char sense, double rightHandSide,

                           double range);


   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 setObjective(const double * array);


     virtual void setColLower(const double * array);


     virtual void setColUpper(const double * array);


 //    using OsiSolverInterface::setRowName ;

 //    virtual void setRowName(int rowIndex, std::string & name) ;

     virtual void setRowName(int rowIndex, std::string  name) ;


 //    using OsiSolverInterface::setColName ;

 //    virtual void setColName(int colIndex, std::string & name) ;

     virtual void setColName(int colIndex, std::string  name) ;


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

   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);

   inline int numberSOS() const

   { return numberSOS_;}

   inline const CoinSet * setInfo() const

   { return setInfo_;}

   virtual int findIntegersAndSOS(bool justCount);


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

   virtual void setObjSense(double s )

   { modelPtr_->setOptimizationDirection( s < 0 ? -1 : 1); }


   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);

   virtual void addCol(const CoinPackedVectorBase& vec,

                       const double collb, const double colub,

                       const double obj, std::string name) ;

   virtual void addCol(int numberElements, const int * rows, const double * elements,

                       const double collb, const double colub,

                       const double obj) ;

   virtual void addCol(int numberElements,

                       const int* rows, const double* elements,

                       const double collb, const double colub,

                       const double obj, std::string name) ;

   virtual void addCols(const int numcols,

                        const CoinPackedVectorBase * const * cols,

                        const double* collb, const double* colub,

                        const double* obj);

   virtual void addCols(const int numcols,

                        const int * columnStarts, const int * rows, const double * elements,

                        const double* collb, const double* colub,

                        const double* obj);

   virtual void deleteCols(const int num, const int * colIndices);


   virtual void addRow(const CoinPackedVectorBase& vec,

                       const double rowlb, const double rowub);

     virtual void addRow(const CoinPackedVectorBase& vec,

                         const double rowlb, const double rowub,

                         std::string name) ;

   virtual void addRow(const CoinPackedVectorBase& vec,

                       const char rowsen, const double rowrhs,

                       const double rowrng);

   virtual void addRow(int numberElements, const int * columns, const double * element,

                       const double rowlb, const double rowub) ;

     virtual void addRow(const CoinPackedVectorBase& vec,

                         const char rowsen, const double rowrhs,

                         const double rowrng, std::string name) ;

   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);


   virtual void addRows(const int numrows,

                        const int * rowStarts, const int * columns, const double * element,

                        const double* rowlb, const double* rowub);

   void modifyCoefficient(int row, int column, double newElement,

                         bool keepZero=false)

         {modelPtr_->modifyCoefficient(row,column,newElement, keepZero);}


   virtual void deleteRows(const int num, const int * rowIndices);

   virtual void saveBaseModel() ;

   virtual void restoreBaseModel(int numberRows);


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

   virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);

   virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);

     virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,

                                           double effectivenessLb = 0.0);


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


 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 ClpMatrixBase& matrix,

                            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 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 int loadFromCoinModel (  CoinModel & modelObject, bool keepSolution=false);


   using OsiSolverInterface::readMps ;

   virtual int readMps(const char *filename,

                       const char *extension = "mps") ;

   int readMps(const char *filename,bool keepNames,bool allowErrors);

   virtual int readMps (const char *filename, const char*extension,

                         int & numberSets, CoinSet ** & sets);


   virtual void writeMps(const char *filename,

                         const char *extension = "mps",

                         double objSense=0.0) const;

   virtual int writeMpsNative(const char *filename,

                              const char ** rowNames, const char ** columnNames,

                              int formatType=0,int numberAcross=2,

                              double objSense=0.0) const ;

   virtual int readLp(const char *filename, const double epsilon = 1e-5);

   virtual void writeLp(const char *filename,

                        const char *extension = "lp",

                        double epsilon = 1e-5,

                        int numberAcross = 10,

                        int decimals = 5,

                        double objSense = 0.0,

                        bool useRowNames = true) const;

   virtual void writeLp(FILE *fp,

                double epsilon = 1e-5,

                int numberAcross = 10,

                int decimals = 5,

                double objSense = 0.0,

                bool useRowNames = true) const;

   virtual void replaceMatrixOptional(const CoinPackedMatrix & matrix);

   virtual void replaceMatrix(const CoinPackedMatrix & matrix) ;


   virtual void passInMessageHandler(CoinMessageHandler * handler);

   void newLanguage(CoinMessages::Language language);

   void setLanguage(CoinMessages::Language language)

   {newLanguage(language);}

   void setLogLevel(int value);

   void generateCpp( FILE * fp);

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


   ClpSimplex * getModelPtr() const ;

   inline ClpSimplex * swapModelPtr(ClpSimplex * newModel)

   { ClpSimplex * model = modelPtr_; modelPtr_=newModel;return model;}

   inline unsigned int specialOptions() const

   { return specialOptions_;}

   void setSpecialOptions(unsigned int value);

   inline int lastAlgorithm() const

   { return lastAlgorithm_;}

   inline void setLastAlgorithm(int value)

   { lastAlgorithm_ = value;}

   inline int cleanupScaling() const

   { return cleanupScaling_;}

   inline void setCleanupScaling(int value)

   { cleanupScaling_=value;}

   inline double smallestElementInCut() const

   { return smallestElementInCut_;}

   inline void setSmallestElementInCut(double value)

   { smallestElementInCut_=value;}

   inline double smallestChangeInCut() const

   { return smallestChangeInCut_;}

   inline void setSmallestChangeInCut(double value)

   { smallestChangeInCut_=value;}

   inline void setSolveOptions(const ClpSolve & options)

   { solveOptions_ = options;}

   virtual int tightenBounds(int lightweight=0);

   int infeasibleOtherWay(char * whichWay);

   virtual CoinBigIndex getSizeL() const;

   virtual CoinBigIndex getSizeU() const;

   const OsiClpDisasterHandler * disasterHandler() const

   { return disasterHandler_;}

   void passInDisasterHandler(OsiClpDisasterHandler * handler);

   ClpLinearObjective * fakeObjective() const

   { return fakeObjective_;}

   void setFakeObjective(ClpLinearObjective * fakeObjective);

   void setFakeObjective(double * fakeObjective);

   void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0);

   virtual void synchronizeModel();

   void setSpecialOptionsMutable(unsigned int value) const;


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


   OsiClpSolverInterface ();


   virtual OsiSolverInterface * clone(bool copyData = true) const;


   OsiClpSolverInterface (const OsiClpSolverInterface &);


   OsiClpSolverInterface (ClpSimplex * rhs, bool reallyOwn=false);


   void releaseClp();


   OsiClpSolverInterface & operator=(const OsiClpSolverInterface& rhs);


   virtual ~OsiClpSolverInterface ();


   virtual void reset();


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


 protected:


   virtual void applyRowCut(const OsiRowCut& rc);


   virtual void applyColCut(const OsiColCut& cc);


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


 protected:

   void gutsOfDestructor();


   void freeCachedResults() const;


   void freeCachedResults0() const;


   void freeCachedResults1() const;


   void extractSenseRhsRange() const;


   void fillParamMaps();

   CoinWarmStartBasis getBasis(ClpSimplex * model) const;

   void setBasis( const CoinWarmStartBasis & basis, ClpSimplex * model);

   void crunch();

   void redoScaleFactors(int numberRows,const CoinBigIndex * starts,

                         const int * indices, const double * elements);

 public:

   void setBasis( const CoinWarmStartBasis & basis);

   inline void setBasis( )

   { setBasis(basis_,modelPtr_);}

   CoinWarmStartDiff * getBasisDiff(const unsigned char * statusArray) const ;

   CoinWarmStartBasis * getBasis(const unsigned char * statusArray) const ;

   void deleteScaleFactors();

   inline const double * upRange() const

   { return rowActivity_;}

   inline const double * downRange() const

   { return columnActivity_;}

   inline void passInRanges(int * array)

   { whichRange_=array;}

   void setSOSData(int numberSOS,const char * type,

                   const int * start,const int * indices, const double * weights=NULL);

   void computeLargestAway();

   inline double largestAway() const

   { return largestAway_;}

   inline void setLargestAway(double value)

   { largestAway_ = value;}

   void lexSolve();


 protected:

   mutable ClpSimplex * modelPtr_;


   mutable char    *rowsense_;


   mutable double  *rhs_;


   mutable double  *rowrange_;


   mutable CoinWarmStartBasis* ws_;

   mutable double * rowActivity_;

   mutable double * columnActivity_;

   ClpNodeStuff stuff_;

   int numberSOS_;

   CoinSet * setInfo_;

   ClpSimplex * smallModel_;

   ClpFactorization * factorization_;

   double smallestElementInCut_;

   double smallestChangeInCut_;

   double largestAway_;

   char * spareArrays_;

   CoinWarmStartBasis basis_;

   int itlimOrig_;


   mutable int lastAlgorithm_;


   bool notOwned_;


   mutable CoinPackedMatrix *matrixByRow_;


   CoinPackedMatrix *matrixByRowAtContinuous_;


   char * integerInformation_;


   int * whichRange_;


   //std::map<OsiIntParam, ClpIntParam> intParamMap_;

   //std::map<OsiDblParam, ClpDblParam> dblParamMap_;

   //std::map<OsiStrParam, ClpStrParam> strParamMap_;


   mutable bool fakeMinInSimplex_ ;

   mutable double *linearObjective_;


   mutable ClpDataSave saveData_;

   ClpSolve solveOptions_;

   int cleanupScaling_;

   mutable unsigned int specialOptions_;

   ClpSimplex * baseModel_;

   int lastNumberRows_;

   ClpSimplex * continuousModel_;

   OsiClpDisasterHandler * disasterHandler_ ;

   ClpLinearObjective * fakeObjective_;

   CoinDoubleArrayWithLength rowScale_;

   CoinDoubleArrayWithLength columnScale_;

 };


 class OsiClpDisasterHandler : public ClpDisasterHandler {

 public:

   virtual void intoSimplex();

   virtual bool check() const ;

   virtual void saveInfo();

   virtual int typeOfDisaster();


   OsiClpDisasterHandler(OsiClpSolverInterface * model = NULL);

   virtual ~OsiClpDisasterHandler();

   // Copy

   OsiClpDisasterHandler(const OsiClpDisasterHandler&);

   // Assignment

   OsiClpDisasterHandler& operator=(const OsiClpDisasterHandler&);

   virtual ClpDisasterHandler * clone() const;


   void setOsiModel(OsiClpSolverInterface * model);

   inline OsiClpSolverInterface * osiModel() const

   { return osiModel_;}

   inline void setWhereFrom(int value)

   { whereFrom_=value;}

   inline int whereFrom() const

   { return whereFrom_;}

   inline void setPhase(int value)

   { phase_=value;}

   inline int phase() const

   { return phase_;}

   bool inTrouble() const;


 protected:

   OsiClpSolverInterface * osiModel_;

   int whereFrom_;

   int phase_;

   bool inTrouble_;

 };

 // So unit test can find out if NDEBUG set

 bool OsiClpHasNDEBUG();

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

 void OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);

 #endif

OsiClpSolverInterface::cleanupScaling
int cleanupScaling() const
Get scaling action option.
Definition: OsiClpSolverInterface.hpp:1045

OsiClpSolverInterface::saveBaseModel
virtual void saveBaseModel()
If solver wants it can save a copy of &quot;base&quot; (continuous) model here.

OsiClpDisasterHandler::setOsiModel
void setOsiModel(OsiClpSolverInterface *model)
set model.

CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:105

OsiClpSolverInterface::getColType
virtual const char * getColType(bool refresh=false) const
Return array of column length 0 - continuous 1 - binary (may get fixed later) 2 - general integer (ma...

OsiClpSolverInterface::setRowUpper
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound  Use DBL_MAX for infinity.

OsiHintStrength
OsiHintStrength
Definition: OsiSolverParameters.hpp:131

OsiClpSolverInterface::setRowPrice
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.

CoinPackedMatrix.hpp

OsiClpSolverInterface::getReducedGradient
virtual void getReducedGradient(double *columnReducedCosts, double *duals, const double *c) const
Get the reduced gradient for the cost vector c.

ClpEventHandler.hpp

OsiClpSolverInterface::lastNumberRows_
int lastNumberRows_
Number of rows when last &quot;scaled&quot;.
Definition: OsiClpSolverInterface.hpp:1406

OsiClpSolverInterface::modifyCoefficient
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Add a named column (primal variable) to the problem.
Definition: OsiClpSolverInterface.hpp:797

OsiClpSolverInterface::disableFactorization
virtual void disableFactorization() const
Undo any setting changes made by enableFactorization.

OsiClpSolverInterface::setObjective
virtual void setObjective(const double *array)
Set the objective coefficients for all columns array [getNumCols()] is an array of values for the obj...

OsiClpSolverInterface::redoScaleFactors
void redoScaleFactors(int numberRows, const CoinBigIndex *starts, const int *indices, const double *elements)
Extend scale factors.

OsiClpSolverInterface::getSizeU
virtual CoinBigIndex getSizeU() const
Return number of entries in U part of current factorization.

OsiClpSolverInterface::newLanguage
void newLanguage(CoinMessages::Language language)
Set language.

OsiIntParam
OsiIntParam
Definition: OsiSolverParameters.hpp:8

OsiClpSolverInterface::setLogLevel
void setLogLevel(int value)
Set log level (will also set underlying solver&#39;s log level)

CoinModel
This is a simple minded model which is stored in a format which makes it easier to construct and modi...
Definition: CoinModel.hpp:161

OsiClpSolverInterface::getRowActivity
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...

OsiClpSolverInterface::loadProblem
virtual void loadProblem(const CoinPackedMatrix &matrix, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub)
Load in an problem by copying the arguments (the constraints on the rows are given by lower and upper...

OsiClpSolverInterface::applyColCut
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (adjust one or more bounds).

OsiClpSolverInterface::lexSolve
void lexSolve()
Sort of lexicographic resolve.

OsiClpSolverInterface::getNumCols
virtual int getNumCols() const
Get number of columns.
Definition: OsiClpSolverInterface.hpp:370

ClpSolve
This is a very simple class to guide algorithms.
Definition: ClpSolve.hpp:20

ClpModel::numberIterations
int numberIterations() const
Number of iterations.
Definition: ClpModel.hpp:363

CoinMessageHandler
Base class for message handling.
Definition: CoinMessageHandler.hpp:327

OsiClpSolverInterface::setHintParam
virtual bool setHintParam(OsiHintParam key, bool yesNo=true, OsiHintStrength strength=OsiHintTry, void *otherInformation=NULL)
Set a hint parameter.

OsiClpSolverInterface::setLargestAway
void setLargestAway(double value)
Set largest amount continuous away from bound.
Definition: OsiClpSolverInterface.hpp:1256

OsiColCut
Column Cut Class.
Definition: OsiColCut.hpp:23

ClpDataSave
This is a tiny class where data can be saved round calls.
Definition: ClpModel.hpp:1269

OsiClpSolverInterface::setColSetBounds
virtual void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously  The default implementation just invokes setColL...

OsiClpSolverInterface::downRange
const double * downRange() const
Sets up working basis as a copy of input and puts in as basis.
Definition: OsiClpSolverInterface.hpp:1242

OsiClpSolverInterface::numberSOS_
int numberSOS_
Number of SOS sets.
Definition: OsiClpSolverInterface.hpp:1291

OsiClpSolverInterface::tightenBounds
virtual int tightenBounds(int lightweight=0)
Tighten bounds - lightweight or very lightweight 0 - normal, 1 lightweight but just integers...

OsiClpSolverInterface::rowActivity_
double * rowActivity_
also save row and column information for hot starts only used in hotstarts so can be casual ...
Definition: OsiClpSolverInterface.hpp:1286

OsiRowCut
Row Cut Class.
Definition: OsiRowCut.hpp:29

ClpLinearObjective
Linear Objective Class.
Definition: ClpLinearObjective.hpp:17

OsiClpSolverInterface::getRowName
virtual std::string getRowName(int rowIndex, unsigned maxLen=static_cast< unsigned >(std::string::npos)) const
Return name of row if one exists or Rnnnnnnn maxLen is currently ignored and only there to match the ...

ClpModel::rowUpper
double * rowUpper() const
Row upper.
Definition: ClpModel.hpp:503

OsiClpSolverInterface::columnActivity_
double * columnActivity_
Pointer to dense vector of row sense indicators.
Definition: OsiClpSolverInterface.hpp:1287

OsiClpSolverInterface::getReducedCost
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.

OsiClpSolverInterface::assignProblem
virtual void assignProblem(CoinPackedMatrix *&matrix, double *&collb, double *&colub, double *&obj, double *&rowlb, double *&rowub)
Load in an problem by assuming ownership of the arguments (the constraints on the rows are given by l...

OsiClpSolverInterface::addRows
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
Add a named column (primal variable) to the problem.

OsiClpSolverInterface::fakeObjective_
ClpLinearObjective * fakeObjective_
Fake objective.
Definition: OsiClpSolverInterface.hpp:1412

OsiClpSolverInterface::setWarmStart
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.

OsiClpSolverInterface::releaseClp
void releaseClp()
Releases so won&#39;t error.

OsiClpSolverInterface::setSOSData
void setSOSData(int numberSOS, const char *type, const int *start, const int *indices, const double *weights=NULL)
Pass in sos stuff from AMPl.

OsiClpSolverInterface::setSmallestElementInCut
void setSmallestElementInCut(double value)
Set smallest allowed element in cut.
Definition: OsiClpSolverInterface.hpp:1067

OsiClpSolverInterface::getBInvARow
virtual void getBInvARow(int row, double *z, double *slack=NULL) const
Get a row of the tableau (slack part in slack if not NULL)

OsiClpSolverInterface::enableFactorization
virtual void enableFactorization() const
Enables simplex mode 1 (tableau access)

OsiClpSolverInterface::passInMessageHandler
virtual void passInMessageHandler(CoinMessageHandler *handler)
Pass in a message handler.

ClpModel::matrix
CoinPackedMatrix * matrix() const
Matrix (if not ClpPackedmatrix be careful about memory leak.
Definition: ClpModel.hpp:697

CoinWarmStartDiff
Abstract base class for warm start `diff&#39; objects.
Definition: CoinWarmStart.hpp:48

OsiClpSolverInterface::freeCachedResults
void freeCachedResults() const
Deletes all mutable stuff.

OsiClpSolverInterface::setSpecialOptions
void setSpecialOptions(unsigned int value)
Get pointer to Clp model.

OsiClpSolverInterface::lastAlgorithm
int lastAlgorithm() const
Last algorithm used , 1 = primal, 2 = dual other unknown.
Definition: OsiClpSolverInterface.hpp:1039

CoinFinite.hpp

OsiClpSolverInterface::getColLower
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
Definition: OsiClpSolverInterface.hpp:396

OsiClpSolverInterface::notOwned_
bool notOwned_
To say if destructor should delete underlying model.
Definition: OsiClpSolverInterface.hpp:1327

OsiClpSolverInterface::matrixByRowAtContinuous_
CoinPackedMatrix * matrixByRowAtContinuous_
Pointer to row-wise copy of continuous problem matrix coefficients.
Definition: OsiClpSolverInterface.hpp:1333

OsiClpSolverInterface::continuousModel_
ClpSimplex * continuousModel_
Continuous model.
Definition: OsiClpSolverInterface.hpp:1408

OsiClpSolverInterface::isPrimalObjectiveLimitReached
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?

OsiClpSolverInterface::setObjSense
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
Definition: OsiClpSolverInterface.hpp:693

ClpModel::optimizationDirection
double optimizationDirection() const
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: ClpModel.hpp:457

CoinDoubleArrayWithLength
double * version
Definition: CoinIndexedVector.hpp:619

OsiClpSolverInterface::factorization_
ClpFactorization * factorization_
factorization for hot starts
Definition: OsiClpSolverInterface.hpp:1297

ClpSimplex.hpp

OsiClpSolverInterface::solveFromHotStart
virtual void solveFromHotStart()
Optimize starting from the hotstart.

OsiClpInfinity
static const double OsiClpInfinity
Definition: OsiClpSolverInterface.hpp:28

OsiClpSolverInterface::setLastAlgorithm
void setLastAlgorithm(int value)
Set last algorithm used , 1 = primal, 2 = dual other unknown.
Definition: OsiClpSolverInterface.hpp:1042

OsiClpSolverInterface::disasterHandler_
OsiClpDisasterHandler * disasterHandler_
Possible disaster handler.
Definition: OsiClpSolverInterface.hpp:1410

OsiClpSolverInterface::setRowLower
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound  Use -DBL_MAX for -infinity.

ClpModel::numberRows
int numberRows() const
Number of rows.
Definition: ClpModel.hpp:315

OsiClpSolverInterface::loadFromCoinModel
virtual int loadFromCoinModel(CoinModel &modelObject, bool keepSolution=false)
This loads a model from a coinModel object - returns number of errors.

OsiClpSolverInterface::getObjValue
virtual double getObjValue() const
Get objective function value.

OsiClpDisasterHandler::inTrouble_
bool inTrouble_
Are we in trouble.
Definition: OsiClpSolverInterface.hpp:1501

OsiClpSolverInterface::smallestChangeInCut
double smallestChangeInCut() const
Get smallest change in cut.
Definition: OsiClpSolverInterface.hpp:1075

OsiClpSolverInterface::setRowSetTypes
virtual void setRowSetTypes(const int *indexFirst, const int *indexLast, const char *senseList, const double *rhsList, const double *rangeList)
Set the type of a number of rows simultaneously  The default implementation just invokes setRowType()...

OsiClpSolverInterface::markHotStart
virtual void markHotStart()
Create a hotstart point of the optimization process.

OsiClpSolverInterface::stopFastDual
void stopFastDual()
Stop fast dual.

OsiClpSolverInterface::operator=
OsiClpSolverInterface & operator=(const OsiClpSolverInterface &rhs)
Assignment operator.

OsiClpSolverInterface::modelPtr_
ClpSimplex * modelPtr_
Clp model represented by this class instance.
Definition: OsiClpSolverInterface.hpp:1266

OsiClpSolverInterface::fillParamMaps
void fillParamMaps()
Sets up working basis as a copy of input and puts in as basis.

OsiClpSolverInterface::getEmptyWarmStart
virtual CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.

OsiClpDisasterHandler::check
virtual bool check() const
Checks if disaster.

CoinPackedMatrix
Sparse Matrix Base Class.
Definition: CoinPackedMatrix.hpp:79

OsiClpSolverInterface::isFreeBinary
virtual bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.

OsiClpSolverInterface::resolve
virtual void resolve()
Resolve an LP relaxation after problem modification.

OsiClpSolverInterface::setFakeObjective
void setFakeObjective(ClpLinearObjective *fakeObjective)
Set fake objective (and take ownership)

OsiClpSolverInterface::getIterationCount
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever &quot;iteration&quot; mean to the solver...
Definition: OsiClpSolverInterface.hpp:515

OsiClpDisasterHandler::setPhase
void setPhase(int value)
Set phase.
Definition: OsiClpSolverInterface.hpp:1467

OsiClpSolverInterface::setColSolution
virtual void setColSolution(const double *colsol)
Set the primal solution column values.

OsiClpSolverInterface::setRowBounds
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.

OsiClpSolverInterface::whichRange_
int * whichRange_
Pointer to variables for which we want range information The number is in [0] memory is not owned by ...
Definition: OsiClpSolverInterface.hpp:1342

OsiClpSolverInterface::disableSimplexInterface
virtual void disableSimplexInterface()
Undo setting changes made by enableSimplexInterface.

OsiClpSolverInterface::setRowName
virtual void setRowName(int rowIndex, std::string name)
Set name of row.

OsiClpSolverInterface::setInfo_
CoinSet * setInfo_
SOS set info.
Definition: OsiClpSolverInterface.hpp:1293

OsiClpSolverInterface::getWarmStart
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.

OsiClpDisasterHandler::setWhereFrom
void setWhereFrom(int value)
Set where from.
Definition: OsiClpSolverInterface.hpp:1461

OsiClpSolverInterface::getNumElements
virtual int getNumElements() const
Get number of nonzero elements.
Definition: OsiClpSolverInterface.hpp:378

OsiClpSolverInterface::getNumRows
virtual int getNumRows() const
Get number of rows.
Definition: OsiClpSolverInterface.hpp:374

OsiCuts
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19

OsiClpSolverInterface::smallestElementInCut_
double smallestElementInCut_
Smallest allowed element in cut.
Definition: OsiClpSolverInterface.hpp:1300

OsiClpSolverInterface::upRange
const double * upRange() const
If doing fast hot start then ranges are computed.
Definition: OsiClpSolverInterface.hpp:1240

OsiSolverInterface::readMps
virtual int readMps(const char *filename, const char *extension="mps")
Read a problem in MPS format from the given filename.

OsiClpSolverInterface::isIterationLimitReached
virtual bool isIterationLimitReached() const
Iteration limit reached?

OsiClpSolverInterface::getMatrixByCol
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.

OsiClpSolverInterface::enableSimplexInterface
virtual void enableSimplexInterface(bool doingPrimal)
Enables simplex mode 2 (individual pivot control)

OsiClpSolverInterface::isProvenPrimalInfeasible
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?

OsiClpSolverInterface::initialSolve
virtual void initialSolve()
Solve initial LP relaxation.

OsiClpSolverInterface::saveData_
ClpDataSave saveData_
To save data in OsiSimplex stuff.
Definition: OsiClpSolverInterface.hpp:1359

ClpNode.hpp

OsiClpSolverInterface::findIntegersAndSOS
virtual int findIntegersAndSOS(bool justCount)
Identify integer variables and SOS and create corresponding objects.

OsiClpSolverInterface::lastAlgorithm_
int lastAlgorithm_
Last algorithm used.
Definition: OsiClpSolverInterface.hpp:1324

OsiClpSolverInterface::setColLower
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound  Use -DBL_MAX for -infinity.

CoinPackedVectorBase
Abstract base class for various sparse vectors.
Definition: CoinPackedVectorBase.hpp:23

OsiClpSolverInterface::getModelPtr
ClpSimplex * getModelPtr() const
Get pointer to Clp model.

OsiClpDisasterHandler::whereFrom_
int whereFrom_
Where from 0 dual (resolve) 1 crunch 2 primal (resolve) 4 dual (initialSolve) 6 primal (initialSolve)...
Definition: OsiClpSolverInterface.hpp:1491

OsiClpSolverInterface::deleteRows
virtual void deleteRows(const int num, const int *rowIndices)
Add a named column (primal variable) to the problem.

OsiClpSolverInterface::isContinuous
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.

OsiClpSolverInterface::disasterHandler
const OsiClpDisasterHandler * disasterHandler() const
Get disaster handler.
Definition: OsiClpSolverInterface.hpp:1099

OsiClpSolverInterface::crunch
void crunch()
Crunch down problem a bit.

OsiClpDisasterHandler
Definition: OsiClpSolverInterface.hpp:1420

OsiClpSolverInterface::specialOptions_
unsigned int specialOptions_
Special options 0x80000000 off 0 simple stuff for branch and bound 1 try and keep work regions as muc...
Definition: OsiClpSolverInterface.hpp:1402

OsiClpSolverInterface::synchronizeModel
virtual void synchronizeModel()
Synchronize model (really if no cuts in tree)

ClpNodeStuff
Definition: ClpNode.hpp:176

OsiClpSolverInterface::deleteCols
virtual void deleteCols(const int num, const int *colIndices)
Add a named column (primal variable) to the problem.

OsiClpSolverInterface::~OsiClpSolverInterface
virtual ~OsiClpSolverInterface()
Destructor.

OsiClpSolverInterface::gutsOfDestructor
void gutsOfDestructor()
The real work of a copy constructor (used by copy and assignment)

OsiClpSolverInterface::copyEnabledSuff
void copyEnabledSuff(OsiClpSolverInterface &rhs)
Copy across enabled stuff from one solver to another.

OsiClpDisasterHandler::clone
virtual ClpDisasterHandler * clone() const
Clone.

OsiClpDisasterHandler::intoSimplex
virtual void intoSimplex()
Into simplex.

OsiClpSolverInterface::cleanupScaling_
int cleanupScaling_
Scaling option When scaling is on it is possible that the scaled problem is feasible but the unscaled...
Definition: OsiClpSolverInterface.hpp:1374

OsiClpSolverInterface::rhs_
double * rhs_
Pointer to dense vector of row right-hand side values.
Definition: OsiClpSolverInterface.hpp:1274

OsiClpSolverInterface::setContinuous
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.

OsiClpSolverInterface::setInteger
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.

OsiClpSolverInterface::passInDisasterHandler
void passInDisasterHandler(OsiClpDisasterHandler *handler)
Pass in disaster handler.

OsiClpSolverInterface::getBInvACol
virtual void getBInvACol(int col, double *vec) const
Get a column of the tableau.

ClpSimplex::Status
Status
enums for status of various sorts.
Definition: ClpSimplex.hpp:78

OsiClpSolverInterface::fakeObjective
ClpLinearObjective * fakeObjective() const
Get fake objective.
Definition: OsiClpSolverInterface.hpp:1104

OsiClpSolverInterface::setColUpper
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound  Use DBL_MAX for infinity.

OsiClpSolverInterface::largestAway
double largestAway() const
Get largest amount continuous away from bound.
Definition: OsiClpSolverInterface.hpp:1253

OsiClpSolverInterface::getBasisDiff
CoinWarmStartDiff * getBasisDiff(const unsigned char *statusArray) const
Warm start difference from basis_ to statusArray.

OsiClpSolverInterface::isIntegerNonBinary
virtual bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.

OsiClpSolverInterface::setSolveOptions
void setSolveOptions(const ClpSolve &options)
Pass in initial solve options.
Definition: OsiClpSolverInterface.hpp:1086

ClpModel::rowLower
double * rowLower() const
Row lower.
Definition: ClpModel.hpp:496

OsiClpSolverInterface::restoreBaseModel
virtual void restoreBaseModel(int numberRows)
Strip off rows to get to this number of rows.

OsiClpSolverInterface::rowScale_
CoinDoubleArrayWithLength rowScale_
Row scale factors (has inverse at end)
Definition: OsiClpSolverInterface.hpp:1414

OsiClpSolverInterface::setSpecialOptionsMutable
void setSpecialOptionsMutable(unsigned int value) const
Set special options in underlying clp solver.

ClpModel::numberColumns
int numberColumns() const
Number of rows.
Definition: ClpModel.hpp:325

OsiClpSolverInterface::getPointerToWarmStart
CoinWarmStartBasis * getPointerToWarmStart()
Get warmstarting information.
Definition: OsiClpSolverInterface.hpp:292

OsiClpSolverInterface::OsiClpSolverInterface
OsiClpSolverInterface()
Default Constructor.

OsiClpSolverInterface::getBasis
CoinWarmStartBasis getBasis(ClpSimplex *model) const
Warm start.

CoinSet
Very simple class for containing data on set.
Definition: CoinMpsIO.hpp:221

OsiClpSolverInterface::getRowLower
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
Definition: OsiClpSolverInterface.hpp:433

OsiStrParam
OsiStrParam
Definition: OsiSolverParameters.hpp:88

OsiClpSolverInterface::computeLargestAway
void computeLargestAway()
Compute largest amount any at continuous away from bound.

OsiClpSolverInterface::rowrange_
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows) ...
Definition: OsiClpSolverInterface.hpp:1279

CoinIndexedVector.hpp

ClpDisasterHandler
Base class for Clp disaster handling.
Definition: ClpEventHandler.hpp:134

OsiClpSolverInterface::setObjCoeff
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.

OsiClpSolverInterface::getStrParam
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.

OsiClpSolverInterface::integerInformation_
char * integerInformation_
Pointer to integer information.
Definition: OsiClpSolverInterface.hpp:1336

OsiClpSolverInterface::crossover
void crossover(int options, int basis)
Solve when primal column and dual row solutions are near-optimal options - 0 no presolve (use primal ...

OsiClpSolverInterface::writeMpsNative
virtual int writeMpsNative(const char *filename, const char **rowNames, const char **columnNames, int formatType=0, int numberAcross=2, double objSense=0.0) const
Write the problem into an mps file of the given filename, names may be null.

OsiClpSolverInterface::setColumnStatus
void setColumnStatus(int iColumn, ClpSimplex::Status status)
Set column status in ClpSimplex and warmStart.

OsiClpSolverInterface::setStrParam
bool setStrParam(OsiStrParam key, const std::string &value)
Set a string parameter.

OsiClpSolverInterface::dualPivotResult
virtual int dualPivotResult(int &colIn, int &sign, int colOut, int outStatus, double &t, CoinPackedVector *dx)
Obtain a result of the dual pivot (similar to the previous method) Differences: entering variable and...

OsiClpSolverInterface::applyCuts
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.

OsiClpSolverInterface::getBInvRow
virtual void getBInvRow(int row, double *z) const
Get a row of the basis inverse.

CoinIndexedVector
Indexed Vector.
Definition: CoinIndexedVector.hpp:104

OsiClpSolverInterface::getRowSense
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.

OsiClpSolverInterface::setLanguage
void setLanguage(CoinMessages::Language language)
Pass in a message handler.
Definition: OsiClpSolverInterface.hpp:1018

OsiClpSolverInterface
Clp Solver Interface.
Definition: OsiClpSolverInterface.hpp:38

OsiClpSolverInterface::writeLp
virtual void writeLp(const char *filename, const char *extension="lp", double epsilon=1e-5, int numberAcross=10, int decimals=5, double objSense=0.0, bool useRowNames=true) const
Write the problem into an Lp file of the given filename.

OsiClpSolverInterface::freeCachedResults0
void freeCachedResults0() const
Deletes all mutable stuff for row ranges etc.

OsiClpSolverInterface::startFastDual
int startFastDual(int options)
Start faster dual - returns negative if problems 1 if infeasible, Options to pass to solver 1 - creat...

OsiClpSolverInterface::infeasibleOtherWay
int infeasibleOtherWay(char *whichWay)
See if any integer variables make infeasible other way.

OsiClpSolverInterface::setDblParam
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.

OsiClpSolverInterface::getBInvCol
virtual void getBInvCol(int col, double *vec) const
Get a column of the basis inverse.

OsiClpDisasterHandler::osiModel
OsiClpSolverInterface * osiModel() const
Get model.
Definition: OsiClpSolverInterface.hpp:1458

OsiClpSolverInterface::addCols
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
Add a named column (primal variable) to the problem.

OsiClpSolverInterface::getDualRays
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.

OsiClpSolverInterface::isAbandoned
virtual bool isAbandoned() const
Are there a numerical difficulties?

OsiSolverInterface.hpp

OsiClpSolverInterface::applyRowCut
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut (append to constraint matrix).

ClpLinearObjective.hpp

OsiSolverInterface
Abstract Base Class for describing an interface to a solver.
Definition: OsiSolverInterface.hpp:62

OsiClpSolverInterface::getRowUpper
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
Definition: OsiClpSolverInterface.hpp:436

CoinWarmStartBasis.hpp

OsiClpSolverInterface::getConstPointerToWarmStart
const CoinWarmStartBasis * getConstPointerToWarmStart() const
Get warmstarting information.
Definition: OsiClpSolverInterface.hpp:295

ClpSimplex
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:70

OsiClpSolverInterface::smallestChangeInCut_
double smallestChangeInCut_
Smallest change in cut.
Definition: OsiClpSolverInterface.hpp:1304

OsiClpSolverInterface::passInRanges
void passInRanges(int *array)
Pass in range array.
Definition: OsiClpSolverInterface.hpp:1245

OsiClpSolverInterface::getMatrixByRow
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.

OsiClpSolverInterface::isDualObjectiveLimitReached
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?

OsiClpSolverInterface::addRow
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a named column (primal variable) to the problem.

OsiClpSolverInterface::canDoSimplexInterface
virtual int canDoSimplexInterface() const
Simplex API capability.

COIN_DBL_MAX
const double COIN_DBL_MAX
Definition: CoinFinite.hpp:18

OsiClpSolverInterface::generateCpp
void generateCpp(FILE *fp)
Create C++ lines to get to current state.

OsiClpSolverInterface::setCleanupScaling
void setCleanupScaling(int value)
Set Scaling option When scaling is on it is possible that the scaled problem is feasible but the unsc...
Definition: OsiClpSolverInterface.hpp:1059

ClpMatrixBase
Abstract base class for Clp Matrices.
Definition: ClpMatrixBase.hpp:38

OsiClpSolverInterface::applyRowCuts
virtual void applyRowCuts(int numberCuts, const OsiRowCut *cuts)
Apply a collection of row cuts which are all effective.

OsiClpSolverInterface::swapModelPtr
ClpSimplex * swapModelPtr(ClpSimplex *newModel)
Set pointer to Clp model and return old.
Definition: OsiClpSolverInterface.hpp:1032

OsiClpSolverInterface::basis_
CoinWarmStartBasis basis_
Warmstart information to be used in resolves.
Definition: OsiClpSolverInterface.hpp:1310

OsiClpHasNDEBUG
bool OsiClpHasNDEBUG()

ClpModel::setOptimizationDirection
void setOptimizationDirection(double value)
Number of rows.

OsiClpSolverInterface::replaceMatrix
virtual void replaceMatrix(const CoinPackedMatrix &matrix)
And if it does matter (not used at present)

ClpModel::columnUpper
double * columnUpper() const
Column Upper.
Definition: ClpModel.hpp:690

OsiClpSolverInterface::setOptionalInteger
void setOptionalInteger(int index)
Set the index-th variable to be an optional integer variable.

OsiClpSolverInterface::ws_
CoinWarmStartBasis * ws_
A pointer to the warmstart information to be used in the hotstarts.
Definition: OsiClpSolverInterface.hpp:1283

OsiClpSolverInterface::getObjSense
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
Definition: OsiClpSolverInterface.hpp:446

OsiClpSolverInterface::setSmallestChangeInCut
void setSmallestChangeInCut(double value)
Set smallest change in cut.
Definition: OsiClpSolverInterface.hpp:1083

OsiClpDisasterHandler::phase
int phase() const
Get phase.
Definition: OsiClpSolverInterface.hpp:1470

OsiClpDisasterHandler::saveInfo
virtual void saveInfo()
saves information for next attempt

OsiClpSolverInterface::isOptionalInteger
bool isOptionalInteger(int colIndex) const
Return true if column is integer but does not have to be declared as such.

OsiClpSolverInterface::getRowRange
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.

OsiClpSolverInterface::addCol
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
Add a named column (primal variable) to the problem.

OsiClpSolverInterface::numberSOS
int numberSOS() const
Number of SOS sets.
Definition: OsiClpSolverInterface.hpp:674

OsiClpSolverInterface::matrixByRow_
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
Definition: OsiClpSolverInterface.hpp:1330

OsiClpSolverInterface::setStuff
void setStuff(double tolerance, double increment)
Sets integer tolerance and increment.

OsiClpSolverInterface::spareArrays_
char * spareArrays_
Arrays for hot starts.
Definition: OsiClpSolverInterface.hpp:1308

CoinWarmStart
Abstract base class for warm start information.
Definition: CoinWarmStart.hpp:21

OsiClpSolverInterface::getColUpper
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
Definition: OsiClpSolverInterface.hpp:399

OsiClpSolverInterface::specialOptions
unsigned int specialOptions() const
Get special options.
Definition: OsiClpSolverInterface.hpp:1035

OsiClpSolverInterface::setRowSetBounds
virtual void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously  The default implementation just invokes setRowLowe...

OsiClpDisasterHandler::typeOfDisaster
virtual int typeOfDisaster()
Type of disaster 0 can fix, 1 abort.

OsiClpSolverInterface::smallModel_
ClpSimplex * smallModel_
Alternate model (hot starts) - but also could be permanent and used for crunch.
Definition: OsiClpSolverInterface.hpp:1295

OsiClpDisasterHandler::phase_
int phase_
phase 0 initial 1 trying continuing with back in and maybe different perturb 2 trying continuing with...
Definition: OsiClpSolverInterface.hpp:1499

CoinPackedVector
Sparse Vector.
Definition: CoinPackedVector.hpp:123

OsiClpSolverInterface::getSizeL
virtual CoinBigIndex getSizeL() const
Return number of entries in L part of current factorization.

OsiClpSolverInterface::getDblParam
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.

OsiClpSolverInterface::isBinary
virtual bool isBinary(int colIndex) const
Return true if variable is binary.

OsiClpSolverInterface::getBasics
virtual void getBasics(int *index) const
Get basic indices (order of indices corresponds to the order of elements in a vector retured by getBI...

OsiClpSolverInterface::extractSenseRhsRange
void extractSenseRhsRange() const
A method that fills up the rowsense_, rhs_ and rowrange_ arrays.

OsiClpSolverInterfaceUnitTest
void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiClpSolverInterface class.

OsiHintParam
OsiHintParam
Definition: OsiSolverParameters.hpp:107

OsiClpSolverInterface::fakeMinInSimplex_
bool fakeMinInSimplex_
Faking min to get proper dual solution signs in simplex API.
Definition: OsiClpSolverInterface.hpp:1349

OsiClpSolverInterface::getInfinity
virtual double getInfinity() const
Get solver&#39;s value for infinity.
Definition: OsiClpSolverInterface.hpp:492

OsiClpSolverInterface::getBasisStatus
virtual void getBasisStatus(int *cstat, int *rstat) const
The following two methods may be replaced by the methods of OsiSolverInterface using OsiWarmStartBasi...

OsiClpSolverInterface::getPrimalRays
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.

OsiClpDisasterHandler::~OsiClpDisasterHandler
virtual ~OsiClpDisasterHandler()
Destructor.

OsiClpDisasterHandler::inTrouble
bool inTrouble() const
are we in trouble

OsiClpSolverInterface::setupForRepeatedUse
void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0)
Set up solver for repeated use by Osi interface.

OsiClpSolverInterface::unmarkHotStart
virtual void unmarkHotStart()
Delete the snapshot.

OsiClpSolverInterface::isProvenDualInfeasible
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?

OsiClpDisasterHandler::OsiClpDisasterHandler
OsiClpDisasterHandler(OsiClpSolverInterface *model=NULL)
Default constructor.

OsiClpDisasterHandler::osiModel_
OsiClpSolverInterface * osiModel_
Pointer to model.
Definition: OsiClpSolverInterface.hpp:1483

OsiClpSolverInterface::replaceMatrixOptional
virtual void replaceMatrixOptional(const CoinPackedMatrix &matrix)
I (JJF) am getting annoyed because I can&#39;t just replace a matrix.

OsiClpSolverInterface::setIntParam
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.

OsiClpSolverInterface::modelCut
OsiRowCut * modelCut(const double *originalLower, const double *originalUpper, int numberRowsAtContinuous, const int *whichGenerator, int typeCut=0)
Return a conflict analysis cut from model If type is 0 then genuine cut, if 1 then only partially pro...

OsiClpSolverInterface::pivot
virtual int pivot(int colIn, int colOut, int outStatus)
Perform a pivot by substituting a colIn for colOut in the basis.

OsiClpSolverInterface::getColName
virtual std::string getColName(int colIndex, unsigned maxLen=static_cast< unsigned >(std::string::npos)) const
Return name of column if one exists or Cnnnnnnn maxLen is currently ignored and only there to match t...

ClpModel::modifyCoefficient
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Modify one element of a matrix.
Definition: ClpModel.hpp:231

OsiClpSolverInterface::freeCachedResults1
void freeCachedResults1() const
Deletes all mutable stuff for matrix etc.

OsiDblParam
OsiDblParam
Definition: OsiSolverParameters.hpp:52

OsiClpSolverInterface::baseModel_
ClpSimplex * baseModel_
Copy of model when option 131072 set.
Definition: OsiClpSolverInterface.hpp:1404

OsiClpSolverInterface::deleteScaleFactors
void deleteScaleFactors()
Delete all scale factor stuff and reset option.

OsiClpSolverInterface::primalPivotResult
virtual int primalPivotResult(int colIn, int sign, int &colOut, int &outStatus, double &t, CoinPackedVector *dx)
Obtain a result of the primal pivot Outputs: colOut – leaving column, outStatus – its status...

OsiClpSolverInterface::largestAway_
double largestAway_
Largest amount continuous away from bound.
Definition: OsiClpSolverInterface.hpp:1306

OsiClpSolverInterface::getMutableMatrixByCol
virtual CoinPackedMatrix * getMutableMatrixByCol() const
Get pointer to mutable column-wise copy of matrix.

ClpModel::objective
double * objective() const
Objective.
Definition: ClpModel.hpp:651

OsiClpSolverInterface::clone
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.

OsiClpSolverInterface::isInteger
virtual bool isInteger(int colIndex) const
Return true if column is integer.

OsiClpSolverInterface::columnScale_
CoinDoubleArrayWithLength columnScale_
Column scale factors (has inverse at end)
Definition: OsiClpSolverInterface.hpp:1416

OsiClpSolverInterface::OsiClpSolverInterfaceUnitTest
friend void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiClpSolverInterface class.

OsiClpSolverInterface::linearObjective_
double * linearObjective_
Linear objective.
Definition: OsiClpSolverInterface.hpp:1356

OsiClpSolverInterface::setInfo
const CoinSet * setInfo() const
SOS set info.
Definition: OsiClpSolverInterface.hpp:677

OsiClpSolverInterface::readMps
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename (defaults to Osi reader) - returns number of errors (see Osi...

OsiClpSolverInterface::writeMps
virtual void writeMps(const char *filename, const char *extension="mps", double objSense=0.0) const
Write the problem into an mps file of the given filename.

OsiClpSolverInterface::setBasisStatus
virtual int setBasisStatus(const int *cstat, const int *rstat)
Set the status of structural/artificial variables and factorize, update solution etc.

OsiClpSolverInterface::rowsense_
char * rowsense_
Pointer to dense vector of row sense indicators.
Definition: OsiClpSolverInterface.hpp:1271

OsiClpSolverInterface::getIntParam
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.

OsiHintTry
This means it is only a hint.
Definition: OsiSolverParameters.hpp:135

OsiClpSolverInterface::basisIsAvailable
virtual bool basisIsAvailable() const
Returns true if a basis is available AND problem is optimal.

OsiClpSolverInterface::getRightHandSide
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.

OsiClpDisasterHandler::whereFrom
int whereFrom() const
Get where from.
Definition: OsiClpSolverInterface.hpp:1464

OsiClpSolverInterface::solveOptions_
ClpSolve solveOptions_
Options for initialSolve.
Definition: OsiClpSolverInterface.hpp:1361

OsiClpSolverInterface::copyEnabledStuff
void copyEnabledStuff(ClpSimplex &rhs)
Copy across enabled stuff from one solver to another.

CoinPackedMatrix::getNumElements
CoinBigIndex getNumElements() const
Number of entries in the packed matrix.
Definition: CoinPackedMatrix.hpp:107

OsiClpSolverInterface::setBasis
void setBasis()
Just puts current basis_ into ClpSimplex model.
Definition: OsiClpSolverInterface.hpp:1231

OsiClpSolverInterface::reset
virtual void reset()
Resets as if default constructor.

OsiClpSolverInterface::setRowType
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row

OsiClpSolverInterface::readLp
virtual int readLp(const char *filename, const double epsilon=1e-5)
Read file in LP format (with names)

CoinMessages::Language
Language
Supported languages.
Definition: CoinMessageHandler.hpp:136

OsiClpSolverInterface::isProvenOptimal
virtual bool isProvenOptimal() const
Is optimality proven?

OsiClpSolverInterface::branchAndBound
virtual void branchAndBound()
Invoke solver&#39;s built-in enumeration algorithm.

OsiClpSolverInterface::getRowPrice
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.

OsiClpSolverInterface::stuff_
ClpNodeStuff stuff_
Stuff for fast dual.
Definition: OsiClpSolverInterface.hpp:1289

OsiClpSolverInterface::smallModelCut
OsiRowCut * smallModelCut(const double *originalLower, const double *originalUpper, int numberRowsAtContinuous, const int *whichGenerator, int typeCut=0)
Return a conflict analysis cut from small model.

CoinWarmStartBasis
The default COIN simplex (basis-oriented) warm start class.
Definition: CoinWarmStartBasis.hpp:40

OsiClpSolverInterface::smallestElementInCut
double smallestElementInCut() const
Get smallest allowed element in cut.
Definition: OsiClpSolverInterface.hpp:1063

OsiClpSolverInterface::itlimOrig_
int itlimOrig_
The original iteration limit before hotstarts started.
Definition: OsiClpSolverInterface.hpp:1312

OsiClpDisasterHandler::operator=
OsiClpDisasterHandler & operator=(const OsiClpDisasterHandler &)
Default constructor.

ClpFactorization
This just implements CoinFactorization when an ClpMatrixBase object is passed.
Definition: ClpFactorization.hpp:35

OsiClpSolverInterface::getColSolution
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.

OsiClpSolverInterface::getObjCoefficients
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
Definition: OsiClpSolverInterface.hpp:439

OsiClpSolverInterface::setColName
virtual void setColName(int colIndex, std::string name)
Set name of column.

OsiClpSolverInterface::resolveGub
virtual void resolveGub(int needed)
Resolve an LP relaxation after problem modification (try GUB)

ClpModel::columnLower
double * columnLower() const
Column Lower.
Definition: ClpModel.hpp:683

OsiClpSolverInterface::setColBounds
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.