Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
OsiClpSolverInterface.hpp
Go to the documentation of this file.
1 // $Id$
2 // Copyright (C) 2000, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 
7 #ifndef OsiClpSolverInterface_H
8 #define OsiClpSolverInterface_H
9 
10 #include <string>
11 #include <cfloat>
12 #include <map>
13 
14 #include "ClpSimplex.hpp"
15 #include "ClpLinearObjective.hpp"
16 #include "CoinPackedMatrix.hpp"
17 #include "OsiSolverInterface.hpp"
18 #include "CoinWarmStartBasis.hpp"
19 #include "ClpEventHandler.hpp"
20 #include "ClpNode.hpp"
21 #include "CoinIndexedVector.hpp"
22 #include "CoinFinite.hpp"
23 
24 class OsiRowCut;
25 class OsiClpUserSolver;
27 class CoinSet;
28 static const double OsiClpInfinity = COIN_DBL_MAX;
29 
30 //#############################################################################
31 
39  virtual public OsiSolverInterface {
40  friend void OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
41 
42 public:
43  //---------------------------------------------------------------------------
46  virtual void initialSolve();
48 
50  virtual void resolve();
51 
53  virtual void resolveGub(int needed);
54 
56  virtual void branchAndBound();
57 
65  void crossover(int options,int basis);
67 
83  virtual int canDoSimplexInterface() const;
84 
93  virtual void enableFactorization() const;
94 
96  virtual void disableFactorization() const;
97 
102  virtual bool basisIsAvailable() const;
103 
119  virtual void getBasisStatus(int* cstat, int* rstat) const;
120 
131  virtual int setBasisStatus(const int* cstat, const int* rstat);
132 
134  virtual void getReducedGradient(double* columnReducedCosts,
135  double * duals,
136  const double * c) const ;
137 
139  virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
140 
145  virtual void getBInvARow(int row, CoinIndexedVector * z, CoinIndexedVector * slack=NULL,
146  bool keepScaled=false) const;
147 
149  virtual void getBInvRow(int row, double* z) const;
150 
152  virtual void getBInvACol(int col, double* vec) const ;
153 
155  virtual void getBInvACol(int col, CoinIndexedVector * vec) const ;
156 
161  virtual void getBInvACol(CoinIndexedVector * vec) const ;
162 
164  virtual void getBInvCol(int col, double* vec) const ;
165 
170  virtual void getBasics(int* index) const;
171 
178  virtual void enableSimplexInterface(bool doingPrimal);
181 
183  virtual void disableSimplexInterface();
185  void copyEnabledStuff(ClpSimplex & rhs);
186 
194  virtual int pivot(int colIn, int colOut, int outStatus);
195 
207  virtual int primalPivotResult(int colIn, int sign,
208  int& colOut, int& outStatus,
209  double& t, CoinPackedVector* dx);
210 
217  virtual int dualPivotResult(int& colIn, int& sign,
218  int colOut, int outStatus,
219  double& t, CoinPackedVector* dx);
220 
221 
223  //---------------------------------------------------------------------------
239  // Set an integer parameter
240  bool setIntParam(OsiIntParam key, int value);
241  // Set an double parameter
242  bool setDblParam(OsiDblParam key, double value);
243  // Set a string parameter
244  bool setStrParam(OsiStrParam key, const std::string & value);
245  // Get an integer parameter
246  bool getIntParam(OsiIntParam key, int& value) const;
247  // Get an double parameter
248  bool getDblParam(OsiDblParam key, double& value) const;
249  // Get a string parameter
250  bool getStrParam(OsiStrParam key, std::string& value) const;
251  // Set a hint parameter - overrides OsiSolverInterface
252  virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
253  OsiHintStrength strength=OsiHintTry,
254  void * otherInformation=NULL);
256 
257  //---------------------------------------------------------------------------
259 
260  virtual bool isAbandoned() const;
263  virtual bool isProvenOptimal() const;
265  virtual bool isProvenPrimalInfeasible() const;
267  virtual bool isProvenDualInfeasible() const;
269  virtual bool isPrimalObjectiveLimitReached() const;
271  virtual bool isDualObjectiveLimitReached() const;
273  virtual bool isIterationLimitReached() const;
275 
276  //---------------------------------------------------------------------------
279 
287  virtual CoinWarmStart *getEmptyWarmStart () const;
288 
290  virtual CoinWarmStart* getWarmStart() const;
293  { return &basis_;}
296  { return &basis_;}
299  virtual bool setWarmStart(const CoinWarmStart* warmstart);
309  virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;
310 
312  void setColumnStatus(int iColumn, ClpSimplex::Status status);
313 
315 
316  //---------------------------------------------------------------------------
323  virtual void markHotStart();
326  virtual void solveFromHotStart();
328  virtual void unmarkHotStart();
337  int startFastDual(int options);
339  void stopFastDual();
341  void setStuff(double tolerance,double increment);
343  OsiRowCut * smallModelCut(const double * originalLower, const double * originalUpper,
344  int numberRowsAtContinuous,const int * whichGenerator,
345  int typeCut=0);
349  OsiRowCut * modelCut(const double * originalLower, const double * originalUpper,
350  int numberRowsAtContinuous,const int * whichGenerator,
351  int typeCut=0);
353 
354  //---------------------------------------------------------------------------
369  virtual int getNumCols() const {
371  return modelPtr_->numberColumns(); }
372 
374  virtual int getNumRows() const {
375  return modelPtr_->numberRows(); }
376 
378  virtual int getNumElements() const {
379  int retVal = 0;
380  const CoinPackedMatrix * matrix =modelPtr_->matrix();
381  if ( matrix != NULL ) retVal=matrix->getNumElements();
382  return retVal; }
383 
386  virtual std::string getRowName(int rowIndex,
387  unsigned maxLen = static_cast<unsigned>(std::string::npos)) const;
388 
391  virtual std::string getColName(int colIndex,
392  unsigned maxLen = static_cast<unsigned>(std::string::npos)) const;
393 
394 
396  virtual const double * getColLower() const { return modelPtr_->columnLower(); }
397 
399  virtual const double * getColUpper() const { return modelPtr_->columnUpper(); }
400 
410  virtual const char * getRowSense() const;
411 
420  virtual const double * getRightHandSide() const ;
421 
430  virtual const double * getRowRange() const ;
431 
433  virtual const double * getRowLower() const { return modelPtr_->rowLower(); }
434 
436  virtual const double * getRowUpper() const { return modelPtr_->rowUpper(); }
437 
439  virtual const double * getObjCoefficients() const
440  { if (fakeMinInSimplex_)
441  return linearObjective_ ;
442  else
443  return modelPtr_->objective(); }
444 
446  virtual double getObjSense() const
449 
451  virtual bool isContinuous(int colNumber) const;
453  virtual bool isBinary(int colIndex) const;
454 
459  virtual bool isInteger(int colIndex) const;
460 
462  virtual bool isIntegerNonBinary(int colIndex) const;
463 
465  virtual bool isFreeBinary(int colIndex) const;
471  virtual const char * getColType(bool refresh=false) const;
472 
478  bool isOptionalInteger(int colIndex) const;
480  void setOptionalInteger(int index);
481 
483  virtual const CoinPackedMatrix * getMatrixByRow() const;
484 
486  virtual const CoinPackedMatrix * getMatrixByCol() const;
487 
489  virtual CoinPackedMatrix * getMutableMatrixByCol() const;
490 
492  virtual double getInfinity() const { return OsiClpInfinity; }
494 
497  virtual const double * getColSolution() const;
499 
501  virtual const double * getRowPrice() const;
502 
504  virtual const double * getReducedCost() const;
505 
508  virtual const double * getRowActivity() const;
509 
511  virtual double getObjValue() const;
512 
515  virtual int getIterationCount() const
516  { return modelPtr_->numberIterations(); }
517 
535  virtual std::vector<double*> getDualRays(int maxNumRays,
536  bool fullRay = false) const;
548  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
549 
551 
552 
553  //---------------------------------------------------------------------------
554 
557  //-------------------------------------------------------------------------
561  virtual void setObjCoeff( int elementIndex, double elementValue );
562 
565  virtual void setColLower( int elementIndex, double elementValue );
566 
569  virtual void setColUpper( int elementIndex, double elementValue );
570 
572  virtual void setColBounds( int elementIndex,
573  double lower, double upper );
574 
583  virtual void setColSetBounds(const int* indexFirst,
584  const int* indexLast,
585  const double* boundList);
586 
589  virtual void setRowLower( int elementIndex, double elementValue );
590 
593  virtual void setRowUpper( int elementIndex, double elementValue ) ;
594 
596  virtual void setRowBounds( int elementIndex,
597  double lower, double upper ) ;
598 
600  virtual void setRowType(int index, char sense, double rightHandSide,
601  double range);
602 
611  virtual void setRowSetBounds(const int* indexFirst,
612  const int* indexLast,
613  const double* boundList);
614 
625  virtual void setRowSetTypes(const int* indexFirst,
626  const int* indexLast,
627  const char* senseList,
628  const double* rhsList,
629  const double* rangeList);
634  virtual void setObjective(const double * array);
635 
640  virtual void setColLower(const double * array);
641 
646  virtual void setColUpper(const double * array);
647 
648 // using OsiSolverInterface::setRowName ;
650 // virtual void setRowName(int rowIndex, std::string & name) ;
651  virtual void setRowName(int rowIndex, std::string name) ;
652 
653 // using OsiSolverInterface::setColName ;
655 // virtual void setColName(int colIndex, std::string & name) ;
656  virtual void setColName(int colIndex, std::string name) ;
657 
659 
660  //-------------------------------------------------------------------------
664  virtual void setContinuous(int index);
666  virtual void setInteger(int index);
669  virtual void setContinuous(const int* indices, int len);
672  virtual void setInteger(const int* indices, int len);
674  inline int numberSOS() const
675  { return numberSOS_;}
677  inline const CoinSet * setInfo() const
678  { return setInfo_;}
688  virtual int findIntegersAndSOS(bool justCount);
690 
691  //-------------------------------------------------------------------------
693  virtual void setObjSense(double s )
694  { modelPtr_->setOptimizationDirection( s < 0 ? -1 : 1); }
695 
706  virtual void setColSolution(const double * colsol);
707 
718  virtual void setRowPrice(const double * rowprice);
719 
720  //-------------------------------------------------------------------------
725 
726  //using OsiSolverInterface::addCol ;
728  virtual void addCol(const CoinPackedVectorBase& vec,
729  const double collb, const double colub,
730  const double obj);
733  virtual void addCol(const CoinPackedVectorBase& vec,
734  const double collb, const double colub,
735  const double obj, std::string name) ;
737  virtual void addCol(int numberElements, const int * rows, const double * elements,
738  const double collb, const double colub,
739  const double obj) ;
742  virtual void addCol(int numberElements,
743  const int* rows, const double* elements,
744  const double collb, const double colub,
745  const double obj, std::string name) ;
747  virtual void addCols(const int numcols,
748  const CoinPackedVectorBase * const * cols,
749  const double* collb, const double* colub,
750  const double* obj);
752  virtual void addCols(const int numcols,
753  const int * columnStarts, const int * rows, const double * elements,
754  const double* collb, const double* colub,
755  const double* obj);
757  virtual void deleteCols(const int num, const int * colIndices);
758 
760  virtual void addRow(const CoinPackedVectorBase& vec,
761  const double rowlb, const double rowub);
768  virtual void addRow(const CoinPackedVectorBase& vec,
769  const double rowlb, const double rowub,
770  std::string name) ;
771  virtual void addRow(const CoinPackedVectorBase& vec,
772  const char rowsen, const double rowrhs,
773  const double rowrng);
775  virtual void addRow(int numberElements, const int * columns, const double * element,
776  const double rowlb, const double rowub) ;
779  virtual void addRow(const CoinPackedVectorBase& vec,
780  const char rowsen, const double rowrhs,
781  const double rowrng, std::string name) ;
783  virtual void addRows(const int numrows,
784  const CoinPackedVectorBase * const * rows,
785  const double* rowlb, const double* rowub);
787  virtual void addRows(const int numrows,
788  const CoinPackedVectorBase * const * rows,
789  const char* rowsen, const double* rowrhs,
790  const double* rowrng);
791 
793  virtual void addRows(const int numrows,
794  const int * rowStarts, const int * columns, const double * element,
795  const double* rowlb, const double* rowub);
797  void modifyCoefficient(int row, int column, double newElement,
798  bool keepZero=false)
799  {modelPtr_->modifyCoefficient(row,column,newElement, keepZero);}
800 
802  virtual void deleteRows(const int num, const int * rowIndices);
805  virtual void saveBaseModel() ;
809  virtual void restoreBaseModel(int numberRows);
810 
811  //-----------------------------------------------------------------------
815  virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
820  virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
843  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
844  double effectivenessLb = 0.0);
845 
847 
848 
849  //---------------------------------------------------------------------------
850 
851 public:
852 
866  virtual void loadProblem(const CoinPackedMatrix& matrix,
867  const double* collb, const double* colub,
868  const double* obj,
869  const double* rowlb, const double* rowub);
870 
878  virtual void assignProblem(CoinPackedMatrix*& matrix,
879  double*& collb, double*& colub, double*& obj,
880  double*& rowlb, double*& rowub);
881 
894  virtual void loadProblem(const CoinPackedMatrix& matrix,
895  const double* collb, const double* colub,
896  const double* obj,
897  const char* rowsen, const double* rowrhs,
898  const double* rowrng);
899 
907  virtual void assignProblem(CoinPackedMatrix*& matrix,
908  double*& collb, double*& colub, double*& obj,
909  char*& rowsen, double*& rowrhs,
910  double*& rowrng);
911 
914  virtual void loadProblem(const ClpMatrixBase& matrix,
915  const double* collb, const double* colub,
916  const double* obj,
917  const double* rowlb, const double* rowub) ;
918 
921  virtual void loadProblem(const int numcols, const int numrows,
922  const CoinBigIndex * start, const int* index,
923  const double* value,
924  const double* collb, const double* colub,
925  const double* obj,
926  const double* rowlb, const double* rowub);
927 
930  virtual void loadProblem(const int numcols, const int numrows,
931  const CoinBigIndex * start, const int* index,
932  const double* value,
933  const double* collb, const double* colub,
934  const double* obj,
935  const char* rowsen, const double* rowrhs,
936  const double* rowrng);
938  virtual int loadFromCoinModel ( CoinModel & modelObject, bool keepSolution=false);
939 
943  virtual int readMps(const char *filename,
944  const char *extension = "mps") ;
947  int readMps(const char *filename,bool keepNames,bool allowErrors);
949  virtual int readMps (const char *filename, const char*extension,
950  int & numberSets, CoinSet ** & sets);
951 
956  virtual void writeMps(const char *filename,
957  const char *extension = "mps",
958  double objSense=0.0) const;
967  virtual int writeMpsNative(const char *filename,
968  const char ** rowNames, const char ** columnNames,
969  int formatType=0,int numberAcross=2,
970  double objSense=0.0) const ;
972  virtual int readLp(const char *filename, const double epsilon = 1e-5);
978  virtual void writeLp(const char *filename,
979  const char *extension = "lp",
980  double epsilon = 1e-5,
981  int numberAcross = 10,
982  int decimals = 5,
983  double objSense = 0.0,
984  bool useRowNames = true) const;
989  virtual void writeLp(FILE *fp,
990  double epsilon = 1e-5,
991  int numberAcross = 10,
992  int decimals = 5,
993  double objSense = 0.0,
994  bool useRowNames = true) const;
1000  virtual void replaceMatrixOptional(const CoinPackedMatrix & matrix);
1002  virtual void replaceMatrix(const CoinPackedMatrix & matrix) ;
1004 
1015  virtual void passInMessageHandler(CoinMessageHandler * handler);
1017  void newLanguage(CoinMessages::Language language);
1019  {newLanguage(language);}
1021  void setLogLevel(int value);
1023  void generateCpp( FILE * fp);
1025  //---------------------------------------------------------------------------
1026 
1029  ClpSimplex * getModelPtr() const ;
1032  inline ClpSimplex * swapModelPtr(ClpSimplex * newModel)
1033  { ClpSimplex * model = modelPtr_; modelPtr_=newModel;return model;}
1035  inline unsigned int specialOptions() const
1036  { return specialOptions_;}
1037  void setSpecialOptions(unsigned int value);
1039  inline int lastAlgorithm() const
1040  { return lastAlgorithm_;}
1042  inline void setLastAlgorithm(int value)
1043  { lastAlgorithm_ = value;}
1045  inline int cleanupScaling() const
1046  { return cleanupScaling_;}
1059  inline void setCleanupScaling(int value)
1060  { cleanupScaling_=value;}
1063  inline double smallestElementInCut() const
1064  { return smallestElementInCut_;}
1067  inline void setSmallestElementInCut(double value)
1068  { smallestElementInCut_=value;}
1075  inline double smallestChangeInCut() const
1076  { return smallestChangeInCut_;}
1083  inline void setSmallestChangeInCut(double value)
1084  { smallestChangeInCut_=value;}
1086  inline void setSolveOptions(const ClpSolve & options)
1087  { solveOptions_ = options;}
1091  virtual int tightenBounds(int lightweight=0);
1093  int infeasibleOtherWay(char * whichWay);
1095  virtual CoinBigIndex getSizeL() const;
1097  virtual CoinBigIndex getSizeU() const;
1100  { return disasterHandler_;}
1105  { return fakeObjective_;}
1109  void setFakeObjective(double * fakeObjective);
1129  void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0);
1131  virtual void synchronizeModel();
1136  void setSpecialOptionsMutable(unsigned int value) const;
1137 
1139 
1140  //---------------------------------------------------------------------------
1141 
1146 
1148  virtual OsiSolverInterface * clone(bool copyData = true) const;
1149 
1152 
1154  OsiClpSolverInterface (ClpSimplex * rhs, bool reallyOwn=false);
1155 
1157  void releaseClp();
1158 
1161 
1163  virtual ~OsiClpSolverInterface ();
1164 
1166  virtual void reset();
1168 
1169  //---------------------------------------------------------------------------
1170 
1171 protected:
1173 
1174 
1175  virtual void applyRowCut(const OsiRowCut& rc);
1176 
1178  virtual void applyColCut(const OsiColCut& cc);
1180 
1181  //---------------------------------------------------------------------------
1182 
1183 protected:
1186  void gutsOfDestructor();
1188 
1190  void freeCachedResults() const;
1191 
1193  void freeCachedResults0() const;
1194 
1196  void freeCachedResults1() const;
1197 
1199  void extractSenseRhsRange() const;
1200 
1202  void fillParamMaps();
1211  CoinWarmStartBasis getBasis(ClpSimplex * model) const;
1220  void setBasis( const CoinWarmStartBasis & basis, ClpSimplex * model);
1222  void crunch();
1224  void redoScaleFactors(int numberRows,const CoinBigIndex * starts,
1225  const int * indices, const double * elements);
1226 public:
1229  void setBasis( const CoinWarmStartBasis & basis);
1231  inline void setBasis( )
1234  CoinWarmStartDiff * getBasisDiff(const unsigned char * statusArray) const ;
1236  CoinWarmStartBasis * getBasis(const unsigned char * statusArray) const ;
1238  void deleteScaleFactors();
1240  inline const double * upRange() const
1241  { return rowActivity_;}
1242  inline const double * downRange() const
1243  { return columnActivity_;}
1245  inline void passInRanges(int * array)
1246  { whichRange_=array;}
1248  void setSOSData(int numberSOS,const char * type,
1249  const int * start,const int * indices, const double * weights=NULL);
1251  void computeLargestAway();
1253  inline double largestAway() const
1254  { return largestAway_;}
1256  inline void setLargestAway(double value)
1257  { largestAway_ = value;}
1259  void lexSolve();
1261 
1262 protected:
1265  mutable ClpSimplex * modelPtr_;
1268 
1270  mutable char *rowsense_;
1272 
1274  mutable double *rhs_;
1275 
1279  mutable double *rowrange_;
1280 
1286  mutable double * rowActivity_;
1287  mutable double * columnActivity_;
1313 
1324  mutable int lastAlgorithm_;
1325 
1328 
1331 
1334 
1337 
1343 
1344  //std::map<OsiIntParam, ClpIntParam> intParamMap_;
1345  //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
1346  //std::map<OsiStrParam, ClpStrParam> strParamMap_;
1347 
1349  mutable bool fakeMinInSimplex_ ;
1356  mutable double *linearObjective_;
1357 
1402  mutable unsigned int specialOptions_;
1418 };
1419 
1421 public:
1425  virtual void intoSimplex();
1428  virtual bool check() const ;
1430  virtual void saveInfo();
1432  virtual int typeOfDisaster();
1434 
1435 
1442  virtual ~OsiClpDisasterHandler();
1443  // Copy
1445  // Assignment
1448  virtual ClpDisasterHandler * clone() const;
1449 
1451 
1456  void setOsiModel(OsiClpSolverInterface * model);
1459  { return osiModel_;}
1461  inline void setWhereFrom(int value)
1462  { whereFrom_=value;}
1464  inline int whereFrom() const
1465  { return whereFrom_;}
1467  inline void setPhase(int value)
1468  { phase_=value;}
1470  inline int phase() const
1471  { return phase_;}
1473  bool inTrouble() const;
1474 
1476 
1477 
1478 protected:
1499  int phase_;
1503 };
1504 // So unit test can find out if NDEBUG set
1505 bool OsiClpHasNDEBUG();
1506 //#############################################################################
1508 void OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
1509 #endif
virtual int pivot(int colIn, int colOut, int outStatus)
Perform a pivot by substituting a colIn for colOut in the basis.
void setStuff(double tolerance, double increment)
Sets integer tolerance and increment.
This is a very simple class to guide algorithms.
Definition: ClpSolve.hpp:20
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
virtual int readMps(const char *filename, const char *extension="mps")
Read a problem in MPS format from the given filename.
char * integerInformation_
Pointer to integer information.
virtual void getBInvACol(int col, double *vec) const
Get a column of the tableau.
unsigned int specialOptions_
Special options 0x80000000 off 0 simple stuff for branch and bound 1 try and keep work regions as muc...
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.
int numberSOS_
Number of SOS sets.
int phase_
phase 0 initial 1 trying continuing with back in and maybe different perturb 2 trying continuing with...
virtual void branchAndBound()
Invoke solver&#39;s built-in enumeration algorithm.
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
virtual void initialSolve()
Solve initial LP relaxation.
virtual void markHotStart()
Create a hotstart point of the optimization process.
CoinBigIndex getNumElements() const
Number of entries in the packed matrix.
double smallestElementInCut_
Smallest allowed element in cut.
void redoScaleFactors(int numberRows, const CoinBigIndex *starts, const int *indices, const double *elements)
Extend scale factors.
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 ...
Status
enums for status of various sorts.
Definition: ClpSimplex.hpp:78
void lexSolve()
Sort of lexicographic resolve.
virtual bool isBinary(int colIndex) const
Return true if variable is binary.
void freeCachedResults0() const
Deletes all mutable stuff for row ranges etc.
int lastAlgorithm_
Last algorithm used.
double * linearObjective_
Linear objective.
void setLargestAway(double value)
Set largest amount continuous away from bound.
double * objective() const
Objective.
Definition: ClpModel.hpp:651
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...
bool isOptionalInteger(int colIndex) const
Return true if column is integer but does not have to be declared as such.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
virtual void passInMessageHandler(CoinMessageHandler *handler)
Pass in a message handler.
Abstract base class for Clp Matrices.
void setWhereFrom(int value)
Set where from.
double * rowActivity_
also save row and column information for hot starts only used in hotstarts so can be casual ...
virtual void getBInvRow(int row, double *z) const
Get a row of the basis inverse.
virtual void disableFactorization() const
Undo any setting changes made by enableFactorization.
virtual void applyRowCuts(int numberCuts, const OsiRowCut *cuts)
Apply a collection of row cuts which are all effective.
double * columnLower() const
Column Lower.
Definition: ClpModel.hpp:683
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...
friend void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiClpSolverInterface class.
virtual int readLp(const char *filename, const double epsilon=1e-5)
Read file in LP format (with names)
virtual bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
virtual void enableSimplexInterface(bool doingPrimal)
Enables simplex mode 2 (individual pivot control)
double * rowUpper() const
Row upper.
Definition: ClpModel.hpp:503
virtual ~OsiClpSolverInterface()
Destructor.
void setSpecialOptionsMutable(unsigned int value) const
Set special options in underlying clp solver.
void newLanguage(CoinMessages::Language language)
Set language.
ClpSimplex * continuousModel_
Continuous model.
double optimizationDirection() const
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: ClpModel.hpp:457
void setSpecialOptions(unsigned int value)
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
ClpSimplex * modelPtr_
Clp model represented by this class instance.
virtual bool isProvenOptimal() const
Is optimality proven?
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.
void copyEnabledSuff(OsiClpSolverInterface &rhs)
Copy across enabled stuff from one solver to another.
Base class for Clp disaster handling.
virtual void synchronizeModel()
Synchronize model (really if no cuts in tree)
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
Column Cut Class.
Definition: OsiColCut.hpp:23
ClpSimplex * smallModel_
Alternate model (hot starts) - but also could be permanent and used for crunch.
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (adjust one or more bounds).
This is a simple minded model which is stored in a format which makes it easier to construct and modi...
Definition: CoinModel.hpp:161
Clp Solver Interface.
ClpSimplex * swapModelPtr(ClpSimplex *newModel)
Set pointer to Clp model and return old.
virtual void getBasics(int *index) const
Get basic indices (order of indices corresponds to the order of elements in a vector retured by getBI...
virtual int getNumElements() const
Get number of nonzero elements.
CoinDoubleArrayWithLength columnScale_
Column scale factors (has inverse at end)
virtual int typeOfDisaster()
Type of disaster 0 can fix, 1 abort.
void setPhase(int value)
Set phase.
This just implements CoinFactorization when an ClpMatrixBase object is passed.
int lastNumberRows_
Number of rows when last &quot;scaled&quot;.
The default COIN simplex (basis-oriented) warm start class.
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()...
void setSmallestElementInCut(double value)
Set smallest allowed element in cut.
void setLogLevel(int value)
Set log level (will also set underlying solver&#39;s log level)
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
ClpSimplex * baseModel_
Copy of model when option 131072 set.
Base class for message handling.
virtual void disableSimplexInterface()
Undo setting changes made by enableSimplexInterface.
void generateCpp(FILE *fp)
Create C++ lines to get to current state.
ClpSimplex * getModelPtr() const
Get pointer to Clp model.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
virtual void getReducedGradient(double *columnReducedCosts, double *duals, const double *c) const
Get the reduced gradient for the cost vector c.
int phase() const
Get phase.
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
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.
int whereFrom() const
Get where from.
int numberColumns() const
Definition: ClpModel.hpp:325
virtual int canDoSimplexInterface() const
Simplex API capability.
OsiClpDisasterHandler * disasterHandler_
Possible disaster handler.
void crossover(int options, int basis)
Solve when primal column and dual row solutions are near-optimal options - 0 no presolve (use primal ...
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
ClpFactorization * factorization_
factorization for hot starts
virtual double getObjValue() const
Get objective function value.
virtual CoinBigIndex getSizeU() const
Return number of entries in U part of current factorization.
Abstract Base Class for describing an interface to a solver.
ClpLinearObjective * fakeObjective() const
Get fake objective.
OsiClpSolverInterface()
Default Constructor.
virtual void restoreBaseModel(int numberRows)
Strip off rows to get to this number of rows.
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...
virtual int findIntegersAndSOS(bool justCount)
Identify integer variables and SOS and create corresponding objects.
Abstract base class for various sparse vectors.
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...
unsigned int specialOptions() const
Get special options.
const double * downRange() const
char * spareArrays_
Arrays for hot starts.
void setBasis()
Just puts current basis_ into ClpSimplex model.
virtual bool check() const
Checks if disaster.
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
int numberSOS() const
Number of SOS sets.
virtual void setObjective(const double *array)
Set the objective coefficients for all columns array [getNumCols()] is an array of values for the obj...
double smallestChangeInCut_
Smallest change in cut.
int cleanupScaling_
Scaling option When scaling is on it is possible that the scaled problem is feasible but the unscaled...
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
bool setStrParam(OsiStrParam key, const std::string &value)
Set a string parameter.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
Add a column (primal variable) to the problem.
double * rhs_
Pointer to dense vector of row right-hand side values.
double * columnUpper() const
Column Upper.
Definition: ClpModel.hpp:690
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
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.
void setCleanupScaling(int value)
Set Scaling option When scaling is on it is possible that the scaled problem is feasible but the unsc...
bool OsiClpHasNDEBUG()
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
bool notOwned_
To say if destructor should delete underlying model.
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:70
void setOptimizationDirection(double value)
ClpDataSave saveData_
To save data in OsiSimplex stuff.
void setSolveOptions(const ClpSolve &options)
Pass in initial solve options.
Indexed Vector.
void gutsOfDestructor()
The real work of a copy constructor (used by copy and assignment)
CoinWarmStartBasis getBasis(ClpSimplex *model) const
Warm start.
int infeasibleOtherWay(char *whichWay)
See if any integer variables make infeasible other way.
const CoinWarmStartBasis * getConstPointerToWarmStart() const
Get warmstarting information.
virtual void setColName(int colIndex, std::string name)
Set name of column.
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
void passInRanges(int *array)
Pass in range array.
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
virtual void intoSimplex()
Into simplex.
OsiClpDisasterHandler(OsiClpSolverInterface *model=NULL)
Default constructor.
void crunch()
Crunch down problem a bit.
int * whichRange_
Pointer to variables for which we want range information The number is in [0] memory is not owned by ...
double * rowLower() const
Row lower.
Definition: ClpModel.hpp:496
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
CoinSet * setInfo_
SOS set info.
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
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...
virtual ~OsiClpDisasterHandler()
Destructor.
virtual void replaceMatrix(const CoinPackedMatrix &matrix)
And if it does matter (not used at present)
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
virtual void setRowName(int rowIndex, std::string name)
Set name of row.
void setFakeObjective(ClpLinearObjective *fakeObjective)
Set fake objective (and take ownership)
const double * upRange() const
If doing fast hot start then ranges are computed.
int itlimOrig_
The original iteration limit before hotstarts started.
This is a tiny class where data can be saved round calls.
Definition: ClpModel.hpp:1269
void setLastAlgorithm(int value)
Set last algorithm used , 1 = primal, 2 = dual other unknown.
void stopFastDual()
Stop fast dual.
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
virtual bool setHintParam(OsiHintParam key, bool yesNo=true, OsiHintStrength strength=OsiHintTry, void *otherInformation=NULL)
Set a hint parameter.
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 & operator=(const OsiClpSolverInterface &rhs)
Assignment operator.
virtual ClpDisasterHandler * clone() const
Clone.
virtual bool isIterationLimitReached() const
Iteration limit reached?
virtual int setBasisStatus(const int *cstat, const int *rstat)
Set the status of structural/artificial variables and factorize, update solution etc.
bool inTrouble_
Are we in trouble.
virtual void reset()
Resets as if default constructor.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
void freeCachedResults() const
Deletes all mutable stuff.
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
virtual bool isAbandoned() const
Are there a numerical difficulties?
ClpNodeStuff stuff_
Stuff for fast dual.
virtual void enableFactorization() const
Enables simplex mode 1 (tableau access)
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows) ...
Row Cut Class.
Definition: OsiRowCut.hpp:29
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut (append to constraint matrix).
Linear Objective Class.
CoinWarmStartDiff * getBasisDiff(const unsigned char *statusArray) const
Warm start difference from basis_ to statusArray.
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
virtual CoinBigIndex getSizeL() const
Return number of entries in L part of current factorization.
CoinPackedMatrix * matrixByRowAtContinuous_
Pointer to row-wise copy of continuous problem matrix coefficients.
virtual bool isInteger(int colIndex) const
Return true if column is integer.
virtual int getNumRows() const
Get number of rows.
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
bool fakeMinInSimplex_
Faking min to get proper dual solution signs in simplex API.
Sparse Matrix Base Class.
static const double OsiClpInfinity
ClpLinearObjective * fakeObjective_
Fake objective.
double largestAway() const
Get largest amount continuous away from bound.
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
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...
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
Add a set of columns (primal variables) to the problem.
CoinWarmStartBasis * getPointerToWarmStart()
Get warmstarting information.
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
ClpSolve solveOptions_
Options for initialSolve.
void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiClpSolverInterface class.
virtual bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
This means it is only a hint.
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
void setOsiModel(OsiClpSolverInterface *model)
set model.
int numberRows() const
Number of rows.
Definition: ClpModel.hpp:315
void copyEnabledStuff(ClpSimplex &rhs)
Copy across enabled stuff from one solver to another.
virtual void resolveGub(int needed)
Resolve an LP relaxation after problem modification (try GUB)
virtual double getInfinity() const
Get solver&#39;s value for infinity.
Language
Supported languages.
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Modify one element of a matrix.
Definition: ClpModel.hpp:231
double largestAway_
Largest amount continuous away from bound.
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...
int CoinBigIndex
virtual void replaceMatrixOptional(const CoinPackedMatrix &matrix)
I (JJF) am getting annoyed because I can&#39;t just replace a matrix.
virtual CoinPackedMatrix * getMutableMatrixByCol() const
Get pointer to mutable column-wise copy of matrix.
int lastAlgorithm() const
Last algorithm used , 1 = primal, 2 = dual other unknown.
CoinWarmStartBasis basis_
Warmstart information to be used in resolves.
void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0)
Set up solver for repeated use by Osi interface.
Abstract base class for warm start `diff&#39; objects.
OsiRowCut * smallModelCut(const double *originalLower, const double *originalUpper, int numberRowsAtContinuous, const int *whichGenerator, int typeCut=0)
Return a conflict analysis cut from small model.
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...
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
void setSOSData(int numberSOS, const char *type, const int *start, const int *indices, const double *weights=NULL)
Pass in sos stuff from AMPl.
int whereFrom_
Where from 0 dual (resolve) 1 crunch 2 primal (resolve) 4 dual (initialSolve) 6 primal (initialSolve)...
virtual void getBInvCol(int col, double *vec) const
Get a column of the basis inverse.
virtual void resolve()
Resolve an LP relaxation after problem modification.
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
virtual void getBasisStatus(int *cstat, int *rstat) const
The following two methods may be replaced by the methods of OsiSolverInterface using OsiWarmStartBasi...
void extractSenseRhsRange() const
A method that fills up the rowsense_, rhs_ and rowrange_ arrays.
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
virtual void unmarkHotStart()
Delete the snapshot.
void setSmallestChangeInCut(double value)
Set smallest change in cut.
void passInDisasterHandler(OsiClpDisasterHandler *handler)
Pass in disaster handler.
virtual int tightenBounds(int lightweight=0)
Tighten bounds - lightweight or very lightweight 0 - normal, 1 lightweight but just integers...
CoinWarmStartBasis * ws_
A pointer to the warmstart information to be used in the hotstarts.
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
const CoinSet * setInfo() const
SOS set info.
void setLanguage(CoinMessages::Language language)
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever &quot;iteration&quot; mean to the solver...
virtual void deleteCols(const int num, const int *colIndices)
Remove a set of columns (primal variables) from the problem.
const OsiClpDisasterHandler * disasterHandler() const
Get disaster handler.
void deleteScaleFactors()
Delete all scale factor stuff and reset option.
OsiClpDisasterHandler & operator=(const OsiClpDisasterHandler &)
OsiClpSolverInterface * osiModel() const
Get model.
void computeLargestAway()
Compute largest amount any at continuous away from bound.
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
Add a set of rows (constraints) to the problem.
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
void setColumnStatus(int iColumn, ClpSimplex::Status status)
Set column status in ClpSimplex and warmStart.
const double COIN_DBL_MAX
Definition: CoinFinite.hpp:18
virtual void getBInvARow(int row, double *z, double *slack=NULL) const
Get a row of the tableau (slack part in slack if not NULL)
int numberIterations() const
Number of iterations.
Definition: ClpModel.hpp:363
virtual int getNumCols() const
Get number of columns.
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
CoinDoubleArrayWithLength rowScale_
Row scale factors (has inverse at end)
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
Sparse Vector.
virtual void saveInfo()
saves information for next attempt
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
virtual bool basisIsAvailable() const
Returns true if a basis is available AND problem is optimal.
void freeCachedResults1() const
Deletes all mutable stuff for matrix etc.
int cleanupScaling() const
Get scaling action option.
virtual CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
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...
void setOptionalInteger(int index)
Set the index-th variable to be an optional integer variable.
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
bool inTrouble() const
are we in trouble
CoinPackedMatrix * matrix() const
Matrix (if not ClpPackedmatrix be careful about memory leak.
Definition: ClpModel.hpp:697
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
double smallestElementInCut() const
Get smallest allowed element in cut.
Abstract base class for warm start information.
double smallestChangeInCut() const
Get smallest change in cut.
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
char * rowsense_
Pointer to dense vector of row sense indicators.
OsiClpSolverInterface * osiModel_
Pointer to model.
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
virtual int loadFromCoinModel(CoinModel &modelObject, bool keepSolution=false)
This loads a model from a coinModel object - returns number of errors.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
int startFastDual(int options)
Start faster dual - returns negative if problems 1 if infeasible, Options to pass to solver 1 - creat...
void releaseClp()
Releases so won&#39;t error.
Very simple class for containing data on set.
Definition: CoinMpsIO.hpp:221
virtual void saveBaseModel()
If solver wants it can save a copy of &quot;base&quot; (continuous) model here.