Clp 1.17.5
Loading...
Searching...
No Matches
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#ifndef OsiClpSolverInterface_H
7#define OsiClpSolverInterface_H
8
9#include <string>
10#include <cfloat>
11#include <map>
12
13#include "ClpSimplex.hpp"
15#include "CoinPackedMatrix.hpp"
16#include "OsiSolverInterface.hpp"
17#include "CoinWarmStartBasis.hpp"
18#include "ClpEventHandler.hpp"
19#include "ClpNode.hpp"
20#include "CoinIndexedVector.hpp"
21#include "CoinFinite.hpp"
22
23class OsiRowCut;
24class OsiClpUserSolver;
26class CoinSet;
27static const double OsiClpInfinity = COIN_DBL_MAX;
28
29//#############################################################################
30
38 friend void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
39
40public:
41 //---------------------------------------------------------------------------
44
45 virtual void initialSolve();
46
48 virtual void resolve();
49
51 virtual void resolveGub(int needed);
52
54 virtual void branchAndBound();
55
63 void crossover(int options, int basis);
65
81 virtual int canDoSimplexInterface() const;
82
91 virtual void enableFactorization() const;
92
94 virtual void disableFactorization() const;
95
100 virtual bool basisIsAvailable() const;
101
117 virtual void getBasisStatus(int *cstat, int *rstat) const;
118
129 virtual int setBasisStatus(const int *cstat, const int *rstat);
130
132 virtual void getReducedGradient(double *columnReducedCosts,
133 double *duals,
134 const double *c) const;
135
137 virtual void getBInvARow(int row, double *z, double *slack = NULL) const;
138
143 virtual void getBInvARow(int row, CoinIndexedVector *z, CoinIndexedVector *slack = NULL,
144 bool keepScaled = false) const;
145
147 virtual void getBInvRow(int row, double *z) const;
148
150 virtual void getBInvACol(int col, double *vec) const;
151
153 virtual void getBInvACol(int col, CoinIndexedVector *vec) const;
154
159 virtual void getBInvACol(CoinIndexedVector *vec) const;
160
162 virtual void getBInvCol(int col, double *vec) const;
163
168 virtual void getBasics(int *index) const;
169
176 virtual void enableSimplexInterface(bool doingPrimal);
177
180
188 virtual int pivot(int colIn, int colOut, int outStatus);
189
201 virtual int primalPivotResult(int colIn, int sign,
202 int &colOut, int &outStatus,
203 double &t, CoinPackedVector *dx);
204
211 virtual int dualPivotResult(int &colIn, int &sign,
212 int colOut, int outStatus,
213 double &t, CoinPackedVector *dx);
214
216 //---------------------------------------------------------------------------
232 // Set an integer parameter
233 bool setIntParam(OsiIntParam key, int value);
234 // Set an double parameter
235 bool setDblParam(OsiDblParam key, double value);
236 // Set a string parameter
237 bool setStrParam(OsiStrParam key, const std::string &value);
238 // Get an integer parameter
239 bool getIntParam(OsiIntParam key, int &value) const;
240 // Get an double parameter
241 bool getDblParam(OsiDblParam key, double &value) const;
242 // Get a string parameter
243 bool getStrParam(OsiStrParam key, std::string &value) const;
244 // Set a hint parameter - overrides OsiSolverInterface
245 virtual bool setHintParam(OsiHintParam key, bool yesNo = true,
246 OsiHintStrength strength = OsiHintTry,
247 void *otherInformation = NULL);
249
250 //---------------------------------------------------------------------------
252
253
254 virtual bool isAbandoned() const;
256 virtual bool isProvenOptimal() const;
258 virtual bool isProvenPrimalInfeasible() const;
260 virtual bool isProvenDualInfeasible() const;
262 virtual bool isPrimalObjectiveLimitReached() const;
264 virtual bool isDualObjectiveLimitReached() const;
266 virtual bool isIterationLimitReached() const;
268
269 //---------------------------------------------------------------------------
272
280 virtual CoinWarmStart *getEmptyWarmStart() const;
281
283 virtual CoinWarmStart *getWarmStart() const;
285 inline CoinWarmStartBasis *getPointerToWarmStart()
286 {
287 return &basis_;
288 }
290 inline const CoinWarmStartBasis *getConstPointerToWarmStart() const
291 {
292 return &basis_;
293 }
296 virtual bool setWarmStart(const CoinWarmStart *warmstart);
306 virtual CoinWarmStart *getPointerToWarmStart(bool &mustDelete);
307
309 void setColumnStatus(int iColumn, ClpSimplex::Status status);
310
312
313 //---------------------------------------------------------------------------
320
321 virtual void markHotStart();
323 virtual void solveFromHotStart();
325 virtual void unmarkHotStart();
334 int startFastDual(int options);
338 void setStuff(double tolerance, double increment);
340 OsiRowCut *smallModelCut(const double *originalLower, const double *originalUpper,
341 int numberRowsAtContinuous, const int *whichGenerator,
342 int typeCut = 0);
346 OsiRowCut *modelCut(const double *originalLower, const double *originalUpper,
347 int numberRowsAtContinuous, const int *whichGenerator,
348 int typeCut = 0);
350
351 //---------------------------------------------------------------------------
366
367 virtual int getNumCols() const
368 {
369 return modelPtr_->numberColumns();
370 }
371
373 virtual int getNumRows() const
374 {
375 return modelPtr_->numberRows();
376 }
377
379 virtual CoinBigIndex getNumElements() const
380 {
381 CoinBigIndex retVal = 0;
382 const CoinPackedMatrix *matrix = modelPtr_->matrix();
383 if (matrix != NULL)
384 retVal = matrix->getNumElements();
385 return retVal;
386 }
387
390 virtual std::string getRowName(int rowIndex,
391 unsigned maxLen = static_cast< unsigned >(std::string::npos)) const;
392
395 virtual std::string getColName(int colIndex,
396 unsigned maxLen = static_cast< unsigned >(std::string::npos)) const;
397
399 virtual const double *getColLower() const { return modelPtr_->columnLower(); }
400
402 virtual const double *getColUpper() const { return modelPtr_->columnUpper(); }
403
413 virtual const char *getRowSense() const;
414
423 virtual const double *getRightHandSide() const;
424
433 virtual const double *getRowRange() const;
434
436 virtual const double *getRowLower() const { return modelPtr_->rowLower(); }
437
439 virtual const double *getRowUpper() const { return modelPtr_->rowUpper(); }
440
442 virtual const double *getObjCoefficients() const
443 {
445 return linearObjective_;
446 else
447 return modelPtr_->objective();
448 }
449
451 virtual double getObjSense() const
452 {
454 }
455
457 virtual bool isContinuous(int colNumber) const;
459 virtual bool isBinary(int colIndex) const;
460
465 virtual bool isInteger(int colIndex) const;
466
468 virtual bool isIntegerNonBinary(int colIndex) const;
469
471 virtual bool isFreeBinary(int colIndex) const;
477 virtual const char *getColType(bool refresh = false) const;
478
484 bool isOptionalInteger(int colIndex) const;
486 void setOptionalInteger(int index);
488 inline bool isHeuristicInteger(int colIndex) const
489 {
490 return (integerInformation_ && integerInformation_[colIndex] == 1);
491 }
493 inline int integerType(int colIndex) const
494 {
495 return integerInformation_ ? integerInformation_[colIndex] : 0;
496 }
498 inline void setIntegerType(int colIndex, int value)
499 {
500 integerInformation_[colIndex] = static_cast< char >(value);
501 }
503 virtual const CoinPackedMatrix *getMatrixByRow() const;
504
506 virtual const CoinPackedMatrix *getMatrixByCol() const;
507
509 virtual CoinPackedMatrix *getMutableMatrixByCol() const;
510
512 virtual double getInfinity() const { return OsiClpInfinity; }
514
518 virtual const double *getColSolution() const;
519
521 virtual const double *getRowPrice() const;
522
524 virtual const double *getReducedCost() const;
525
528 virtual const double *getRowActivity() const;
529
531 virtual double getObjValue() const;
532
535 virtual int getIterationCount() const
536 {
537 return modelPtr_->numberIterations();
538 }
539
557 virtual std::vector< double * > getDualRays(int maxNumRays,
558 bool fullRay = false) const;
570 virtual std::vector< double * > getPrimalRays(int maxNumRays) const;
571
573
574
575 //---------------------------------------------------------------------------
576
579 //-------------------------------------------------------------------------
583 virtual void setObjCoeff(int elementIndex, double elementValue);
584
587 virtual void setColLower(int elementIndex, double elementValue);
588
591 virtual void setColUpper(int elementIndex, double elementValue);
592
594 virtual void setColBounds(int elementIndex,
595 double lower, double upper);
596
605 virtual void setColSetBounds(const int *indexFirst,
606 const int *indexLast,
607 const double *boundList);
608
611 virtual void setRowLower(int elementIndex, double elementValue);
612
615 virtual void setRowUpper(int elementIndex, double elementValue);
616
618 virtual void setRowBounds(int elementIndex,
619 double lower, double upper);
620
622 virtual void setRowType(int index, char sense, double rightHandSide,
623 double range);
624
633 virtual void setRowSetBounds(const int *indexFirst,
634 const int *indexLast,
635 const double *boundList);
636
647 virtual void setRowSetTypes(const int *indexFirst,
648 const int *indexLast,
649 const char *senseList,
650 const double *rhsList,
651 const double *rangeList);
656 virtual void setObjective(const double *array);
657
662 virtual void setColLower(const double *array);
663
668 virtual void setColUpper(const double *array);
669
670 // using OsiSolverInterface::setRowName ;
672 // virtual void setRowName(int rowIndex, std::string & name) ;
673 virtual void setRowName(int rowIndex, std::string name);
674
675 // using OsiSolverInterface::setColName ;
677 // virtual void setColName(int colIndex, std::string & name) ;
678 virtual void setColName(int colIndex, std::string name);
679
681
682 //-------------------------------------------------------------------------
686 virtual void setContinuous(int index);
688 virtual void setInteger(int index);
691 virtual void setContinuous(const int *indices, int len);
694 virtual void setInteger(const int *indices, int len);
696 inline int numberSOS() const
697 {
698 return numberSOS_;
699 }
701 inline const CoinSet *setInfo() const
702 {
703 return setInfo_;
704 }
706 void replaceSetInfo(int numberSOS, CoinSet *setInfo);
716 virtual int findIntegersAndSOS(bool justCount);
718
719 //-------------------------------------------------------------------------
721 virtual void setObjSense(double s)
722 {
723 modelPtr_->setOptimizationDirection(s < 0 ? -1 : 1);
724 }
725
736 virtual void setColSolution(const double *colsol);
737
748 virtual void setRowPrice(const double *rowprice);
749
750 //-------------------------------------------------------------------------
755
756 //using OsiSolverInterface::addCol ;
758 virtual void addCol(const CoinPackedVectorBase &vec,
759 const double collb, const double colub,
760 const double obj);
763 virtual void addCol(const CoinPackedVectorBase &vec,
764 const double collb, const double colub,
765 const double obj, std::string name);
767 virtual void addCol(int numberElements, const int *rows, const double *elements,
768 const double collb, const double colub,
769 const double obj);
772 virtual void addCol(int numberElements,
773 const int *rows, const double *elements,
774 const double collb, const double colub,
775 const double obj, std::string name);
777 virtual void addCols(const int numcols,
778 const CoinPackedVectorBase *const *cols,
779 const double *collb, const double *colub,
780 const double *obj);
782 virtual void addCols(const int numcols,
783 const CoinBigIndex *columnStarts, const int *rows, const double *elements,
784 const double *collb, const double *colub,
785 const double *obj);
787 virtual void deleteCols(const int num, const int *colIndices);
788
790 virtual void addRow(const CoinPackedVectorBase &vec,
791 const double rowlb, const double rowub);
798 virtual void addRow(const CoinPackedVectorBase &vec,
799 const double rowlb, const double rowub,
800 std::string name);
801 virtual void addRow(const CoinPackedVectorBase &vec,
802 const char rowsen, const double rowrhs,
803 const double rowrng);
805 virtual void addRow(int numberElements, const int *columns, const double *element,
806 const double rowlb, const double rowub);
809 virtual void addRow(const CoinPackedVectorBase &vec,
810 const char rowsen, const double rowrhs,
811 const double rowrng, std::string name);
813 virtual void addRows(const int numrows,
814 const CoinPackedVectorBase *const *rows,
815 const double *rowlb, const double *rowub);
817 virtual void addRows(const int numrows,
818 const CoinPackedVectorBase *const *rows,
819 const char *rowsen, const double *rowrhs,
820 const double *rowrng);
821
823 virtual void addRows(const int numrows,
824 const CoinBigIndex *rowStarts, const int *columns, const double *element,
825 const double *rowlb, const double *rowub);
827 void modifyCoefficient(int row, int column, double newElement,
828 bool keepZero = false)
829 {
830 modelPtr_->modifyCoefficient(row, column, newElement, keepZero);
831 }
832
834 virtual void deleteRows(const int num, const int *rowIndices);
837 virtual void saveBaseModel();
841 virtual void restoreBaseModel(int numberRows);
842
843 //-----------------------------------------------------------------------
847 virtual void applyRowCuts(int numberCuts, const OsiRowCut *cuts);
852 virtual void applyRowCuts(int numberCuts, const OsiRowCut **cuts);
875 virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs,
876 double effectivenessLb = 0.0);
877
879
880
881 //---------------------------------------------------------------------------
882
883public:
897 virtual void loadProblem(const CoinPackedMatrix &matrix,
898 const double *collb, const double *colub,
899 const double *obj,
900 const double *rowlb, const double *rowub);
901
909 virtual void assignProblem(CoinPackedMatrix *&matrix,
910 double *&collb, double *&colub, double *&obj,
911 double *&rowlb, double *&rowub);
912
925 virtual void loadProblem(const CoinPackedMatrix &matrix,
926 const double *collb, const double *colub,
927 const double *obj,
928 const char *rowsen, const double *rowrhs,
929 const double *rowrng);
930
938 virtual void assignProblem(CoinPackedMatrix *&matrix,
939 double *&collb, double *&colub, double *&obj,
940 char *&rowsen, double *&rowrhs,
941 double *&rowrng);
942
945 virtual void loadProblem(const ClpMatrixBase &matrix,
946 const double *collb, const double *colub,
947 const double *obj,
948 const double *rowlb, const double *rowub);
949
952 virtual void loadProblem(const int numcols, const int numrows,
953 const CoinBigIndex *start, const int *index,
954 const double *value,
955 const double *collb, const double *colub,
956 const double *obj,
957 const double *rowlb, const double *rowub);
958
961 virtual void loadProblem(const int numcols, const int numrows,
962 const CoinBigIndex *start, const int *index,
963 const double *value,
964 const double *collb, const double *colub,
965 const double *obj,
966 const char *rowsen, const double *rowrhs,
967 const double *rowrng);
969 virtual int loadFromCoinModel(CoinModel &modelObject, bool keepSolution = false);
970
973 virtual int readMps(const char *filename,
974 const char *extension = "mps");
977 int readMps(const char *filename, bool keepNames, bool allowErrors);
979 virtual int readMps(const char *filename, const char *extension,
980 int &numberSets, CoinSet **&sets);
981
986 virtual void writeMps(const char *filename,
987 const char *extension = "mps",
988 double objSense = 0.0) const;
997 virtual int writeMpsNative(const char *filename,
998 const char **rowNames, const char **columnNames,
999 int formatType = 0, int numberAcross = 2,
1000 double objSense = 0.0) const;
1002 virtual int readLp(const char *filename, const double epsilon = 1e-5);
1008 virtual void writeLp(const char *filename,
1009 const char *extension = "lp",
1010 double epsilon = 1e-5,
1011 int numberAcross = 10,
1012 int decimals = 5,
1013 double objSense = 0.0,
1014 bool useRowNames = true) const;
1019 virtual void writeLp(FILE *fp,
1020 double epsilon = 1e-5,
1021 int numberAcross = 10,
1022 int decimals = 5,
1023 double objSense = 0.0,
1024 bool useRowNames = true) const;
1030 virtual void replaceMatrixOptional(const CoinPackedMatrix &matrix);
1032 virtual void replaceMatrix(const CoinPackedMatrix &matrix);
1034
1045 virtual void passInMessageHandler(CoinMessageHandler *handler);
1047 void newLanguage(CoinMessages::Language language);
1048 void setLanguage(CoinMessages::Language language)
1049 {
1050 newLanguage(language);
1051 }
1053 void setLogLevel(int value);
1055 void generateCpp(FILE *fp);
1057 //---------------------------------------------------------------------------
1058
1065 {
1066 ClpSimplex *model = modelPtr_;
1067 modelPtr_ = newModel;
1068 return model;
1069 }
1071 inline unsigned int specialOptions() const
1072 {
1073 return specialOptions_;
1074 }
1075 void setSpecialOptions(unsigned int value);
1077 inline int lastAlgorithm() const
1078 {
1079 return lastAlgorithm_;
1080 }
1082 inline void setLastAlgorithm(int value)
1083 {
1084 lastAlgorithm_ = value;
1085 }
1087 inline int cleanupScaling() const
1088 {
1089 return cleanupScaling_;
1090 }
1103 inline void setCleanupScaling(int value)
1104 {
1105 cleanupScaling_ = value;
1106 }
1109 inline double smallestElementInCut() const
1110 {
1111 return smallestElementInCut_;
1112 }
1115 inline void setSmallestElementInCut(double value)
1116 {
1117 smallestElementInCut_ = value;
1118 }
1125 inline double smallestChangeInCut() const
1126 {
1127 return smallestChangeInCut_;
1128 }
1135 inline void setSmallestChangeInCut(double value)
1136 {
1137 smallestChangeInCut_ = value;
1138 }
1140 inline void setSolveOptions(const ClpSolve &options)
1141 {
1142 solveOptions_ = options;
1143 }
1147 virtual int tightenBounds(int lightweight = 0);
1149 int infeasibleOtherWay(char *whichWay);
1151 virtual CoinBigIndex getSizeL() const;
1153 virtual CoinBigIndex getSizeU() const;
1156 {
1157 return disasterHandler_;
1158 }
1163 {
1164 return fakeObjective_;
1165 }
1189 void setupForRepeatedUse(int senseOfAdventure = 0, int printOut = 0);
1191 virtual void synchronizeModel();
1196 void setSpecialOptionsMutable(unsigned int value) const;
1197
1199
1200 //---------------------------------------------------------------------------
1201
1206
1208 virtual OsiSolverInterface *clone(bool copyData = true) const;
1209
1212
1214 OsiClpSolverInterface(ClpSimplex *rhs, bool reallyOwn = false);
1215
1218
1221
1224
1226 virtual void reset();
1228
1229 //---------------------------------------------------------------------------
1230
1231protected:
1233
1234
1235 virtual void applyRowCut(const OsiRowCut &rc);
1236
1238 virtual void applyColCut(const OsiColCut &cc);
1240
1241 //---------------------------------------------------------------------------
1242
1243protected:
1248
1250 void freeCachedResults() const;
1251
1254
1257
1260
1271 CoinWarmStartBasis getBasis(ClpSimplex *model) const;
1280 void setBasis(const CoinWarmStartBasis &basis, ClpSimplex *model);
1282 void crunch();
1284 void redoScaleFactors(int numberRows, const CoinBigIndex *starts,
1285 const int *indices, const double *elements);
1286
1287public:
1290 void setBasis(const CoinWarmStartBasis &basis);
1292 inline void setBasis()
1293 {
1295 }
1297 CoinWarmStartDiff *getBasisDiff(const unsigned char *statusArray) const;
1299 CoinWarmStartBasis *getBasis(const unsigned char *statusArray) const;
1303 inline const double *upRange() const
1304 {
1305 return rowActivity_;
1306 }
1307 inline const double *downRange() const
1308 {
1309 return columnActivity_;
1310 }
1312 inline void passInRanges(int *array)
1313 {
1314 whichRange_ = array;
1315 }
1317 void setSOSData(int numberSOS, const char *type,
1318 const int *start, const int *indices, const double *weights = NULL);
1322 inline double largestAway() const
1323 {
1324 return largestAway_;
1325 }
1327 inline void setLargestAway(double value)
1328 {
1329 largestAway_ = value;
1330 }
1332 void lexSolve();
1335 {
1336 return continuousModel_;
1337 }
1339 inline void setContinuousModel(ClpSimplex *model)
1340 {
1341 continuousModel_ = model;
1342 }
1344
1345protected:
1351
1354 mutable char *rowsense_;
1355
1357 mutable double *rhs_;
1358
1362 mutable double *rowrange_;
1363
1366 mutable CoinWarmStartBasis *ws_;
1369 mutable double *rowActivity_;
1370 mutable double *columnActivity_;
1376 CoinSet *setInfo_;
1393 CoinWarmStartBasis basis_;
1396
1407 mutable int lastAlgorithm_;
1408
1411
1413 mutable CoinPackedMatrix *matrixByRow_;
1414
1416 CoinPackedMatrix *matrixByRowAtContinuous_;
1417
1420
1426
1427 //std::map<OsiIntParam, ClpIntParam> intParamMap_;
1428 //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
1429 //std::map<OsiStrParam, ClpStrParam> strParamMap_;
1430
1432 mutable bool fakeMinInSimplex_;
1439 mutable double *linearObjective_;
1440
1486 mutable unsigned int specialOptions_;
1498 CoinDoubleArrayWithLength rowScale_;
1500 CoinDoubleArrayWithLength columnScale_;
1502};
1503
1505public:
1510 virtual void intoSimplex();
1512 virtual bool check() const;
1514 virtual void saveInfo();
1516 virtual int typeOfDisaster();
1518
1526 // Copy
1528 // Assignment
1531 virtual ClpDisasterHandler *clone() const;
1532
1534
1542 {
1543 return osiModel_;
1544 }
1546 inline void setWhereFrom(int value)
1547 {
1548 whereFrom_ = value;
1549 }
1551 inline int whereFrom() const
1552 {
1553 return whereFrom_;
1554 }
1556 inline void setPhase(int value)
1557 {
1558 phase_ = value;
1559 }
1561 inline int phase() const
1562 {
1563 return phase_;
1564 }
1566 bool inTrouble() const;
1567
1569
1570protected:
1595};
1596// So unit test can find out if NDEBUG set
1598//#############################################################################
1600void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
1601#endif
1602
1603/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
1604*/
#define OsiSolverInterface
Definition Idiot.hpp:14
static const double OsiClpInfinity
void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiClpSolverInterface class.
bool OsiClpHasNDEBUG()
This is a tiny class where data can be saved round calls.
Base class for Clp disaster handling.
This just implements CoinFactorization when an ClpMatrixBase object is passed.
Linear Objective Class.
Abstract base class for Clp Matrices.
double * columnUpper() const
Column Upper.
Definition ClpModel.hpp:763
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Modify one element of a matrix.
Definition ClpModel.hpp:234
double optimizationDirection() const
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition ClpModel.hpp:489
double * rowLower() const
Row lower.
Definition ClpModel.hpp:539
double * objective() const
Objective.
Definition ClpModel.hpp:717
int numberColumns() const
Definition ClpModel.hpp:332
int numberRows() const
Number of rows.
Definition ClpModel.hpp:319
CoinPackedMatrix * matrix() const
Matrix (if not ClpPackedmatrix be careful about memory leak.
Definition ClpModel.hpp:772
void setOptimizationDirection(double value)
double * columnLower() const
Column Lower.
Definition ClpModel.hpp:754
int numberIterations() const
Number of iterations.
Definition ClpModel.hpp:378
double * rowUpper() const
Row upper.
Definition ClpModel.hpp:548
This solves LPs using the simplex method.
Status
enums for status of various sorts.
This is a very simple class to guide algorithms.
Definition ClpSolve.hpp:20
void setWhereFrom(int value)
Set where from.
int whereFrom() const
Get where from.
virtual ~OsiClpDisasterHandler()
Destructor.
bool inTrouble_
Are we in trouble.
bool inTrouble() const
are we in trouble
OsiClpDisasterHandler(const OsiClpDisasterHandler &)
virtual void intoSimplex()
Into simplex.
virtual void saveInfo()
saves information for next attempt
OsiClpSolverInterface * osiModel_
Pointer to model.
int phase_
phase 0 initial 1 trying continuing with back in and maybe different perturb 2 trying continuing with...
OsiClpSolverInterface * osiModel() const
Get model.
int whereFrom_
Where from 0 dual (resolve) 1 crunch 2 primal (resolve) 4 dual (initialSolve) 6 primal (initialSolve)
OsiClpDisasterHandler & operator=(const OsiClpDisasterHandler &)
virtual bool check() const
Checks if disaster.
OsiClpDisasterHandler(OsiClpSolverInterface *model=NULL)
Default constructor.
void setOsiModel(OsiClpSolverInterface *model)
set model.
virtual int typeOfDisaster()
Type of disaster 0 can fix, 1 abort.
virtual ClpDisasterHandler * clone() const
Clone.
void setPhase(int value)
Set phase.
double * linearObjective_
Linear objective.
void setFakeObjective(ClpLinearObjective *fakeObjective)
Set fake objective (and take ownership)
ClpSimplex * swapModelPtr(ClpSimplex *newModel)
Set pointer to Clp model and return old.
void lexSolve()
Sort of lexicographic resolve.
void crunch()
Crunch down problem a bit.
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const char *rowsen, const double *rowrhs, const double *rowrng)
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
int infeasibleOtherWay(char *whichWay)
See if any integer variables make infeasible other way.
CoinDoubleArrayWithLength rowScale_
Row scale factors (has inverse at end)
virtual CoinBigIndex getSizeL() const
Return number of entries in L part of current factorization.
virtual int tightenBounds(int lightweight=0)
Tighten bounds - lightweight or very lightweight 0 - normal, 1 lightweight but just integers,...
char * spareArrays_
Arrays for hot starts.
void setFakeObjective(double *fakeObjective)
Set fake objective.
virtual void getBInvRow(int row, double *z) const
Get a row of the basis inverse.
int lastAlgorithm_
Last algorithm used.
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
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...
virtual CoinBigIndex getSizeU() const
Return number of entries in U part of current factorization.
virtual void replaceMatrixOptional(const CoinPackedMatrix &matrix)
I (JJF) am getting annoyed because I can't just replace a matrix.
virtual void addRow(const CoinPackedVectorBase &vec, const char rowsen, const double rowrhs, const double rowrng, std::string name)
Add a named row (constraint) to the problem.
virtual void enableFactorization() const
Enables simplex mode 1 (tableau access)
ClpSimplex * getContinuousModel() const
Get continuous model.
virtual bool isIterationLimitReached() const
Iteration limit reached?
void redoScaleFactors(int numberRows, const CoinBigIndex *starts, const int *indices, const double *elements)
Extend scale factors.
virtual ~OsiClpSolverInterface()
Destructor.
virtual void replaceMatrix(const CoinPackedMatrix &matrix)
And if it does matter (not used at present)
virtual bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
ClpSimplex * getModelPtr() const
Get pointer to Clp model.
void releaseClp()
Releases so won't error.
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub, std::string name)
Add a named row (constraint) to the problem.
ClpLinearObjective * fakeObjective_
Fake objective.
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
virtual int readMps(const char *filename, const char *extension, int &numberSets, CoinSet **&sets)
Read an mps file.
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
virtual void addRows(const int numrows, const CoinBigIndex *rowStarts, const int *columns, const double *element, const double *rowlb, const double *rowub)
virtual CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows)
virtual void getBasics(int *index) const
Get basic indices (order of indices corresponds to the order of elements in a vector retured by getBI...
void setBasis(const CoinWarmStartBasis &basis)
Sets up working basis as a copy of input and puts in as basis.
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
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 markHotStart()
Create a hotstart point of the optimization process.
virtual int findIntegersAndSOS(bool justCount)
Identify integer variables and SOS and create corresponding objects.
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
virtual void getBInvARow(int row, CoinIndexedVector *z, CoinIndexedVector *slack=NULL, bool keepScaled=false) const
Get a row of the tableau (slack part in slack if not NULL) If keepScaled is true then scale factors n...
double * rowActivity_
also save row and column information for hot starts only used in hotstarts so can be casual
virtual void saveBaseModel()
If solver wants it can save a copy of "base" (continuous) model here.
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
void setLogLevel(int value)
Set log level (will also set underlying solver's log level)
void passInDisasterHandler(OsiClpDisasterHandler *handler)
Pass in disaster handler.
virtual void getBInvACol(int col, double *vec) const
Get a column of the tableau.
virtual void disableSimplexInterface()
Undo setting changes made by enableSimplexInterface.
virtual void setContinuous(const int *indices, int len)
Set the variables listed in indices (which is of length len) to be continuous variables.
OsiClpSolverInterface(const OsiClpSolverInterface &)
Copy constructor.
const CoinSet * setInfo() const
SOS set info.
bool setStrParam(OsiStrParam key, const std::string &value)
virtual int pivot(int colIn, int colOut, int outStatus)
Perform a pivot by substituting a colIn for colOut in the basis.
void freeCachedResults() const
Deletes all mutable stuff.
double largestAway_
Largest amount continuous away from bound.
OsiClpSolverInterface & operator=(const OsiClpSolverInterface &rhs)
Assignment operator.
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (adjust one or more bounds).
virtual void deleteRows(const int num, const int *rowIndices)
virtual void disableFactorization() const
Undo any setting changes made by enableFactorization.
virtual void deleteCols(const int num, const int *colIndices)
virtual int getNumCols() const
Get number of columns.
void setContinuousModel(ClpSimplex *model)
Set continuous model.
virtual void resolveGub(int needed)
Resolve an LP relaxation after problem modification (try GUB)
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
virtual void setRowName(int rowIndex, std::string name)
Set name of row.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
void setLargestAway(double value)
Set largest amount continuous away from bound.
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
ClpFactorization * factorization_
factorization for hot starts
virtual int canDoSimplexInterface() const
Simplex API capability.
virtual void getBInvACol(int col, CoinIndexedVector *vec) const
Get a column of the tableau.
ClpSimplex * baseModel_
Copy of model when option 131072 set.
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
void setSpecialOptionsMutable(unsigned int value) const
Set special options in underlying clp solver.
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
void extractSenseRhsRange() const
A method that fills up the rowsense_, rhs_ and rowrange_ arrays.
virtual void branchAndBound()
Invoke solver's built-in enumeration algorithm.
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
int itlimOrig_
The original iteration limit before hotstarts started.
virtual int setBasisStatus(const int *cstat, const int *rstat)
Set the status of structural/artificial variables and factorize, update solution etc.
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
double smallestChangeInCut() const
Get smallest change in cut.
ClpLinearObjective * fakeObjective() const
Get fake objective.
virtual void setInteger(const int *indices, int len)
Set the variables listed in indices (which is of length len) to be integer variables.
virtual double getInfinity() const
Get solver's value for infinity.
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
virtual void initialSolve()
Solve initial LP relaxation.
void freeCachedResults0() const
Deletes all mutable stuff for row ranges etc.
virtual bool isProvenOptimal() const
Is optimality proven?
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
virtual void applyRowCuts(int numberCuts, const OsiRowCut **cuts)
Apply a collection of row cuts which are all effective.
void replaceSetInfo(int numberSOS, CoinSet *setInfo)
Replace setInfo (takes over ownership)
ClpNodeStuff stuff_
Stuff for fast dual.
OsiClpSolverInterface()
Default Constructor.
virtual void applyRowCuts(int numberCuts, const OsiRowCut *cuts)
Apply a collection of row cuts which are all effective.
virtual void addRow(int numberElements, const int *columns, const double *element, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
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...
virtual void setColName(int colIndex, std::string name)
Set name of column.
void generateCpp(FILE *fp)
Create C++ lines to get to current state.
bool notOwned_
To say if destructor should delete underlying model.
double * rhs_
Pointer to dense vector of row right-hand side values.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever "iteration" mean to the solver.
virtual void enableSimplexInterface(bool doingPrimal)
Enables simplex mode 2 (individual pivot control)
virtual bool isAbandoned() const
Are there a numerical difficulties?
void stopFastDual()
Stop fast dual.
CoinSet * setInfo_
SOS set info.
virtual void setObjective(const double *array)
Set the objective coefficients for all columns array [getNumCols()] is an array of values for the obj...
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 synchronizeModel()
Synchronize model (really if no cuts in tree)
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()...
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)
Just like the other loadProblem() methods except that the matrix is given in a standard column major ...
virtual void setColLower(const double *array)
Set the lower bounds for all columns array [getNumCols()] is an array of values for the objective.
ClpSolve solveOptions_
Options for initialSolve.
OsiClpDisasterHandler * disasterHandler_
Possible disaster handler.
virtual void resolve()
Resolve an LP relaxation after problem modification.
friend void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiClpSolverInterface class.
virtual bool setHintParam(OsiHintParam key, bool yesNo=true, OsiHintStrength strength=OsiHintTry, void *otherInformation=NULL)
void crossover(int options, int basis)
Solve when primal column and dual row solutions are near-optimal options - 0 no presolve (use primal ...
int integerType(int colIndex) const
Return integer type (0,1,2=optional,3=sc,4=scint)
void newLanguage(CoinMessages::Language language)
Set language.
virtual void setColUpper(const double *array)
Set the upper bounds for all columns array [getNumCols()] is an array of values for the objective.
const CoinWarmStartBasis * getConstPointerToWarmStart() const
Get warmstarting information.
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
unsigned int specialOptions() const
Get special options.
virtual void loadProblem(const CoinPackedMatrix &matrix, const double *collb, const double *colub, const double *obj, const char *rowsen, const double *rowrhs, const double *rowrng)
Load in an problem by copying the arguments (the constraints on the rows are given by sense/rhs/range...
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
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)
Just like the other loadProblem() methods except that the matrix is given in a standard column major ...
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
unsigned int specialOptions_
Special options 0x80000000 off 0 simple stuff for branch and bound 1 try and keep work regions as muc...
virtual void unmarkHotStart()
Delete the snapshot.
virtual bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
void freeCachedResults1() const
Deletes all mutable stuff for matrix etc.
virtual CoinWarmStart * getPointerToWarmStart(bool &mustDelete)
Get warm start information.
virtual void assignProblem(CoinPackedMatrix *&matrix, double *&collb, double *&colub, double *&obj, char *&rowsen, double *&rowrhs, double *&rowrng)
Load in an problem by assuming ownership of the arguments (the constraints on the rows are given by s...
const OsiClpDisasterHandler * disasterHandler() const
Get disaster handler.
void deleteScaleFactors()
Delete all scale factor stuff and reset option.
void computeLargestAway()
Compute largest amount any at continuous away from bound.
int lastNumberRows_
Number of rows when last "scaled".
void setLastAlgorithm(int value)
Set last algorithm used , 1 = primal, 2 = dual other unknown.
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 getNumRows() const
Get number of rows.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj, std::string name)
Add a named column (primal variable) to the problem.
CoinWarmStartBasis * getPointerToWarmStart()
Get warmstarting information.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
int cleanupScaling() const
Get scaling action option.
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
CoinDoubleArrayWithLength columnScale_
Column scale factors (has inverse at end)
virtual void loadProblem(const ClpMatrixBase &matrix, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub)
Just like the other loadProblem() methods except that the matrix is given as a ClpMatrixBase.
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
ClpSimplex * continuousModel_
Continuous model.
void setSpecialOptions(unsigned int value)
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
void setSmallestElementInCut(double value)
Set smallest allowed element in cut.
bool fakeMinInSimplex_
Faking min to get proper dual solution signs in simplex API.
int startFastDual(int options)
Start faster dual - returns negative if problems 1 if infeasible, Options to pass to solver 1 - creat...
double largestAway() const
Get largest amount continuous away from bound.
int * whichRange_
Pointer to variables for which we want range information The number is in [0] memory is not owned by ...
bool getIntParam(OsiIntParam key, int &value) const
OsiClpSolverInterface(ClpSimplex *rhs, bool reallyOwn=false)
Borrow constructor - only delete one copy.
void passInRanges(int *array)
Pass in range array.
bool getDblParam(OsiDblParam key, double &value) const
void setStuff(double tolerance, double increment)
Sets integer tolerance and increment.
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 const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
virtual CoinBigIndex getNumElements() const
Get number of nonzero elements.
double smallestElementInCut() const
Get smallest allowed element in cut.
double smallestElementInCut_
Smallest allowed element in cut.
CoinWarmStartBasis * ws_
A pointer to the warmstart information to be used in the hotstarts.
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 ...
virtual bool isBinary(int colIndex) const
Return true if variable is binary.
void setSmallestChangeInCut(double value)
Set smallest change in cut.
ClpSimplex * modelPtr_
Clp model represented by this class instance.
CoinPackedMatrix * matrixByRowAtContinuous_
Pointer to row-wise copy of continuous problem matrix coefficients.
double smallestChangeInCut_
Smallest change in cut.
virtual void reset()
Resets as if default constructor.
void setBasis(const CoinWarmStartBasis &basis, ClpSimplex *model)
Sets up working basis as a copy of input.
void setLanguage(CoinMessages::Language language)
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
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,...
ClpSimplex * smallModel_
Alternate model (hot starts) - but also could be permanent and used for crunch.
virtual void addCol(int numberElements, const int *rows, const double *elements, const double collb, const double colub, const double obj, std::string name)
Add a named column (primal variable) to the problem.
void setBasis()
Just puts current basis_ into ClpSimplex model.
int lastAlgorithm() const
Last algorithm used , 1 = primal, 2 = dual other unknown.
virtual void getBInvARow(int row, double *z, double *slack=NULL) const
Get a row of the tableau (slack part in slack if not NULL)
CoinWarmStartDiff * getBasisDiff(const unsigned char *statusArray) const
Warm start difference from basis_ to statusArray.
virtual CoinPackedMatrix * getMutableMatrixByCol() const
Get pointer to mutable column-wise copy of matrix.
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
const double * downRange() const
bool isOptionalInteger(int colIndex) const
Return true if column is integer but does not have to be declared as such.
void setColumnStatus(int iColumn, ClpSimplex::Status status)
Set column status in ClpSimplex and warmStart.
virtual void getReducedGradient(double *columnReducedCosts, double *duals, const double *c) const
Get the reduced gradient for the cost vector c.
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
char * rowsense_
Pointer to dense vector of row sense indicators.
virtual bool isInteger(int colIndex) const
Return true if column is integer.
ClpDataSave saveData_
To save data in OsiSimplex stuff.
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
virtual int loadFromCoinModel(CoinModel &modelObject, bool keepSolution=false)
This loads a model from a coinModel object - returns number of errors.
virtual int readLp(const char *filename, const double epsilon=1e-5)
Read file in LP format (with names)
CoinWarmStartBasis getBasis(ClpSimplex *model) const
Warm start.
void setOptionalInteger(int index)
Set the index-th variable to be an optional integer variable.
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.
virtual void passInMessageHandler(CoinMessageHandler *handler)
Pass in a message handler.
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.
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0)
Set up solver for repeated use by Osi interface.
void gutsOfDestructor()
The real work of a copy constructor (used by copy and assignment)
void setSOSData(int numberSOS, const char *type, const int *start, const int *indices, const double *weights=NULL)
Pass in sos stuff from AMPl.
char * integerInformation_
Pointer to integer information.
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
CoinWarmStartBasis basis_
Warmstart information to be used in resolves.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
bool setDblParam(OsiDblParam key, double value)
void setCleanupScaling(int value)
Set Scaling option When scaling is on it is possible that the scaled problem is feasible but the unsc...
bool setIntParam(OsiIntParam key, int value)
void setIntegerType(int colIndex, int value)
Set integer type (0,1,2=optional,3=sc,4=scint)
virtual void addCol(int numberElements, const int *rows, const double *elements, const double collb, const double colub, const double obj)
Add a column (primal variable) to the problem.
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.
virtual double getObjValue() const
Get objective function value.
virtual void addRow(const CoinPackedVectorBase &vec, const char rowsen, const double rowrhs, const double rowrng)
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
void setSolveOptions(const ClpSolve &options)
Pass in initial solve options.
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...
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
CoinWarmStartBasis * getBasis(const unsigned char *statusArray) const
Warm start from statusArray.
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 readMps(const char *filename, bool keepNames, bool allowErrors)
Read an mps file from the given filename returns number of errors (see OsiMpsReader class)
bool isHeuristicInteger(int colIndex) const
Return true only if integer and not optional.
int numberSOS_
Number of SOS sets.
int numberSOS() const
Number of SOS sets.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
virtual void getBInvACol(CoinIndexedVector *vec) const
Update (i.e.
virtual void addCols(const int numcols, const CoinBigIndex *columnStarts, const int *rows, const double *elements, const double *collb, const double *colub, const double *obj)
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut (append to constraint matrix).
virtual bool basisIsAvailable() const
Returns true if a basis is available AND problem is optimal.
virtual void writeLp(FILE *fp, double epsilon=1e-5, int numberAcross=10, int decimals=5, double objSense=0.0, bool useRowNames=true) const
Write the problem into the file pointed to by the parameter fp.
int cleanupScaling_
Scaling option When scaling is on it is possible that the scaled problem is feasible but the unscaled...
const double * upRange() const
If doing fast hot start then ranges are computed.
virtual void getBasisStatus(int *cstat, int *rstat) const
The following two methods may be replaced by the methods of OsiSolverInterface using OsiWarmStartBasi...
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
bool getStrParam(OsiStrParam key, std::string &value) const
virtual void getBInvCol(int col, double *vec) const
Get a column of the basis inverse.
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
OsiRowCut * smallModelCut(const double *originalLower, const double *originalUpper, int numberRowsAtContinuous, const int *whichGenerator, int typeCut=0)
Return a conflict analysis cut from small model.
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...
virtual void restoreBaseModel(int numberRows)
Strip off rows to get to this number of rows.