Clp  1.17.6
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
OsiCpxSolverInterface.hpp
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // name: OSI Interface for CPLEX
3 // author: Tobias Pfender
4 // Konrad-Zuse-Zentrum Berlin (Germany)
5 // email: pfender@zib.de
6 // date: 09/25/2000
7 // license: this file may be freely distributed under the terms of EPL
8 // comments: please scan this file for '???' and read the comments
9 //-----------------------------------------------------------------------------
10 // Copyright (C) 2000, Tobias Pfender, International Business Machines
11 // Corporation and others. All Rights Reserved.
12 
13 #ifndef OsiCpxSolverInterface_H
14 #define OsiCpxSolverInterface_H
15 
16 #include "OsiSolverInterface.hpp"
17 #include "CoinWarmStartBasis.hpp"
18 #include "OsiColCut.hpp"
19 #include "OsiRowCut.hpp"
20 
21 typedef struct cpxlp *CPXLPptr;
22 typedef struct cpxenv *CPXENVptr;
23 
29 class OsiCpxSolverInterface : virtual public OsiSolverInterface {
30  friend void OsiCpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
31 
32 public:
33  //---------------------------------------------------------------------------
36  virtual void initialSolve();
38 
40  virtual void resolve();
41 
43  virtual void branchAndBound();
45 
46  //---------------------------------------------------------------------------
62  // Set an integer parameter
63  bool setIntParam(OsiIntParam key, int value);
64  // Set an double parameter
65  bool setDblParam(OsiDblParam key, double value);
66  // Set a string parameter
67  bool setStrParam(OsiStrParam key, const std::string &value);
68  // Get an integer parameter
69  bool getIntParam(OsiIntParam key, int &value) const;
70  // Get an double parameter
71  bool getDblParam(OsiDblParam key, double &value) const;
72  // Get a string parameter
73  bool getStrParam(OsiStrParam key, std::string &value) const;
74  // Set mipstart option (pass column solution to CPLEX before MIP start)
75  void setMipStart(bool value) { domipstart = value; }
76  // Get mipstart option value
77  bool getMipStart() const { return domipstart; }
79 
80  //---------------------------------------------------------------------------
82 
83  virtual bool isAbandoned() const;
86  virtual bool isProvenOptimal() const;
88  virtual bool isProvenPrimalInfeasible() const;
90  virtual bool isProvenDualInfeasible() const;
92  virtual bool isPrimalObjectiveLimitReached() const;
94  virtual bool isDualObjectiveLimitReached() const;
96  virtual bool isIterationLimitReached() const;
98 
99  //---------------------------------------------------------------------------
102 
110 
112  virtual CoinWarmStart *getWarmStart() const;
115  virtual bool setWarmStart(const CoinWarmStart *warmstart);
117 
118  //---------------------------------------------------------------------------
125  virtual void markHotStart();
128  virtual void solveFromHotStart();
130  virtual void unmarkHotStart();
132 
133  //---------------------------------------------------------------------------
148  virtual int getNumCols() const;
150 
152  virtual int getNumRows() const;
153 
155  virtual int getNumElements() const;
156 
158  virtual const double *getColLower() const;
159 
161  virtual const double *getColUpper() const;
162 
172  virtual const char *getRowSense() const;
173 
182  virtual const double *getRightHandSide() const;
183 
192  virtual const double *getRowRange() const;
193 
195  virtual const double *getRowLower() const;
196 
198  virtual const double *getRowUpper() const;
199 
201  virtual const double *getObjCoefficients() const;
202 
204  virtual double getObjSense() const;
205 
207  virtual bool isContinuous(int colNumber) const;
208 
209 #if 0
210  virtual bool isBinary(int columnNumber) const;
212 
217  virtual bool isInteger(int columnNumber) const;
218 
220  virtual bool isIntegerNonBinary(int columnNumber) const;
221 
223  virtual bool isFreeBinary(int columnNumber) const;
224 #endif
225 
227  virtual const CoinPackedMatrix *getMatrixByRow() const;
228 
230  virtual const CoinPackedMatrix *getMatrixByCol() const;
231 
233  virtual double getInfinity() const;
235 
238  virtual const double *getColSolution() const;
240 
242  virtual const double *getRowPrice() const;
243 
245  virtual const double *getReducedCost() const;
246 
249  virtual const double *getRowActivity() const;
250 
252  virtual double getObjValue() const;
253 
256  virtual int getIterationCount() const;
257 
275  virtual std::vector< double * > getDualRays(int maxNumRays,
276  bool fullRay = false) const;
288  virtual std::vector< double * > getPrimalRays(int maxNumRays) const;
289 
290 #if 0
291 
293  virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
294  const;
295 #endif
296 
297 
298 
299  //---------------------------------------------------------------------------
300 
303  //-------------------------------------------------------------------------
307  virtual void setObjCoeff(int elementIndex, double elementValue);
308 
310  virtual void setObjCoeffSet(const int *indexFirst,
311  const int *indexLast,
312  const double *coeffList);
313 
317  virtual void setColLower(int elementIndex, double elementValue);
318 
322  virtual void setColUpper(int elementIndex, double elementValue);
323 
327  virtual void setColBounds(int elementIndex,
328  double lower, double upper);
329 
337  virtual void setColSetBounds(const int *indexFirst,
338  const int *indexLast,
339  const double *boundList);
340 
343  virtual void setRowLower(int elementIndex, double elementValue);
344 
347  virtual void setRowUpper(int elementIndex, double elementValue);
348 
352  virtual void setRowBounds(int elementIndex,
353  double lower, double upper);
354 
356  virtual void setRowType(int index, char sense, double rightHandSide,
357  double range);
358 
366  virtual void setRowSetBounds(const int *indexFirst,
367  const int *indexLast,
368  const double *boundList);
369 
379  virtual void setRowSetTypes(const int *indexFirst,
380  const int *indexLast,
381  const char *senseList,
382  const double *rhsList,
383  const double *rangeList);
385 
386  //-------------------------------------------------------------------------
390  virtual void setContinuous(int index);
392  virtual void setInteger(int index);
395  virtual void setContinuous(const int *indices, int len);
398  virtual void setInteger(const int *indices, int len);
400 
401  //-------------------------------------------------------------------------
403  virtual void setObjSense(double s);
404 
415  virtual void setColSolution(const double *colsol);
416 
427  virtual void setRowPrice(const double *rowprice);
428 
429  //-------------------------------------------------------------------------
436  virtual void addCol(const CoinPackedVectorBase &vec,
437  const double collb, const double colub,
438  const double obj);
439 
442  virtual void addCols(const int numcols,
443  const CoinPackedVectorBase *const *cols,
444  const double *collb, const double *colub,
445  const double *obj);
447  virtual void deleteCols(const int num, const int *colIndices);
448 
451  virtual void addRow(const CoinPackedVectorBase &vec,
452  const double rowlb, const double rowub);
454  virtual void addRow(const CoinPackedVectorBase &vec,
455  const char rowsen, const double rowrhs,
456  const double rowrng);
457 
460  virtual void addRows(const int numrows,
461  const CoinPackedVectorBase *const *rows,
462  const double *rowlb, const double *rowub);
464  virtual void addRows(const int numrows,
465  const CoinPackedVectorBase *const *rows,
466  const char *rowsen, const double *rowrhs,
467  const double *rowrng);
469  virtual void deleteRows(const int num, const int *rowIndices);
470 
471 #if 0
472  // ??? implemented in OsiSolverInterface
473  //-----------------------------------------------------------------------
495  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
496  double effectivenessLb = 0.0);
497 #endif
498 
499 
500 
501  //---------------------------------------------------------------------------
502 
516  virtual void loadProblem(const CoinPackedMatrix &matrix,
517  const double *collb, const double *colub,
518  const double *obj,
519  const double *rowlb, const double *rowub);
520 
528  virtual void assignProblem(CoinPackedMatrix *&matrix,
529  double *&collb, double *&colub, double *&obj,
530  double *&rowlb, double *&rowub);
531 
544  virtual void loadProblem(const CoinPackedMatrix &matrix,
545  const double *collb, const double *colub,
546  const double *obj,
547  const char *rowsen, const double *rowrhs,
548  const double *rowrng);
549 
557  virtual void assignProblem(CoinPackedMatrix *&matrix,
558  double *&collb, double *&colub, double *&obj,
559  char *&rowsen, double *&rowrhs,
560  double *&rowrng);
561 
564  virtual void loadProblem(const int numcols, const int numrows,
565  const int *start, const int *index,
566  const double *value,
567  const double *collb, const double *colub,
568  const double *obj,
569  const double *rowlb, const double *rowub);
570 
573  virtual void loadProblem(const int numcols, const int numrows,
574  const int *start, const int *index,
575  const double *value,
576  const double *collb, const double *colub,
577  const double *obj,
578  const char *rowsen, const double *rowrhs,
579  const double *rowrng);
580 
583  virtual int readMps(const char *filename,
584  const char *extension = "mps");
585 
590  virtual void writeMps(const char *filename,
591  const char *extension = "mps",
592  double objSense = 0.0) const;
593 
595 
605 
606  //---------------------------------------------------------------------------
607 
636  };
637  CPXLPptr getLpPtr(int keepCached = KEEPCACHED_NONE);
638 
643 
645  const char *getCtype() const;
646 
651 
653  virtual OsiSolverInterface *clone(bool copyData = true) const;
654 
657 
660 
662  virtual ~OsiCpxSolverInterface();
663 
665  virtual void reset();
667 
668  /***************************************************************************/
688 
692  virtual int canDoSimplexInterface() const;
693 
698  virtual void enableSimplexInterface(int doingPrimal) {};
699 
703  virtual void disableSimplexInterface() {};
704 
708  virtual void enableFactorization() const {};
709 
713  virtual void disableFactorization() const {};
714 
716  virtual bool basisIsAvailable() const;
717 
721  virtual void getBasisStatus(int *cstat, int *rstat) const;
722 
724  virtual void getBInvARow(int row, double *z, double *slack = NULL) const;
725 
727  virtual void getBInvRow(int row, double *z) const;
728 
730  virtual void getBInvACol(int col, double *vec) const;
731 
733  virtual void getBInvCol(int col, double *vec) const;
734 
740  virtual void getBasics(int *index) const;
742  void switchToLP();
743 
745  void switchToMIP();
746 
748  /***************************************************************************/
749 
750 protected:
752  CPXLPptr getMutableLpPtr() const;
753 
756 
759  virtual void applyRowCut(const OsiRowCut &rc);
761 
765  virtual void applyColCut(const OsiColCut &cc);
767 
768 private:
771  void resizeColType(int minsize);
773 
775  void freeColType();
777 
780 
782  void gutsOfCopy(const OsiCpxSolverInterface &source);
783 
785  void gutsOfConstructor();
786 
788  void gutsOfDestructor();
789 
791  void freeCachedColRim();
792 
794  void freeCachedRowRim();
795 
797  void freeCachedResults();
798 
800  void freeCachedMatrix();
801 
803  void freeCachedData(int keepCached = KEEPCACHED_NONE);
804 
806  void freeAllMemory();
807 
809 
812  mutable CPXENVptr env_;
815  mutable CPXLPptr lp_;
816 
823 
826  mutable double *obj_;
828 
830  mutable double *collower_;
831 
833  mutable double *colupper_;
834 
836  mutable char *rowsense_;
837 
839  mutable double *rhs_;
840 
842  mutable double *rowrange_;
843 
845  mutable double *rowlower_;
846 
848  mutable double *rowupper_;
849 
851  mutable double *colsol_;
852 
854  mutable double *rowsol_;
855 
857  mutable double *redcost_;
858 
860  mutable double *rowact_;
861 
864 
868 
871  char *coltype_;
873 
876 
878  mutable bool probtypemip_;
879 
882 
885 
887 };
888 
889 //#############################################################################
891 void OsiCpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
892 
893 #endif
894 
895 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
896 */
free only cached matrix and LP solution information
problem matrix: matrix ordered by column and by row
virtual int readMps(const char *filename, const char *extension="mps")
Read a problem in MPS format from the given filename.
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
void freeCachedRowRim()
free cached row rim vectors
discard all cached data (default)
keepCachedFlag
Get pointer to CPLEX model and free all specified cached data entries (combined with logical or-opera...
virtual bool isIterationLimitReached() const
Iteration limit reached?
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.
void passInMessageHandler(CoinMessageHandler *handler)
Pass in a message handler It is the client&#39;s responsibility to destroy a message handler installed by...
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
double * rowlower_
Pointer to dense vector of row lower bounds.
void gutsOfCopy(const OsiCpxSolverInterface &source)
The real work of a copy constructor (used by copy and assignment)
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
CPXLPptr lp_
CPLEX model represented by this class instance.
virtual bool isProvenOptimal() const
Is optimality proven?
void freeCachedMatrix()
free cached matrices
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -COIN_DBL_MAX for -infinity.
virtual void getBInvARow(int row, double *z, double *slack=NULL) const
Get a row of the tableau (slack part in slack if not NULL)
bool domipstart
Whether to pass a column solution to CPLEX before starting MIP solve (copymipstart) ...
virtual int getNumElements() const
Get number of nonzero elements.
double * rowupper_
Pointer to dense vector of row upper bounds.
virtual bool isIntegerNonBinary(int colIndex) const
Return true if the variable is general integer.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
LP solution: primal and dual solution, reduced costs, row activities.
virtual void setColLower(int elementIndex, double elementValue)=0
Set a single column lower bound.
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
CPXLPptr getMutableLpPtr() const
Get LP Pointer for const methods.
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
virtual void unmarkHotStart()
Delete the snapshot.
OsiCpxSolverInterface()
Default Constructor.
void OsiCpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiCpxSolverInterface class.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
virtual void disableSimplexInterface()
Useless function, defined only for compatibility with OsiSimplexInterface.
virtual void enableFactorization() const
Useless function, defined only for compatibility with OsiSimplexInterface.
virtual void setObjCoeffSet(const int *indexFirst, const int *indexLast, const double *coeffList)
Set a a set of objective function coefficients.
virtual bool isAbandoned() const
Are there a numerical difficulties?
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
virtual double getInfinity() const
Get solver&#39;s value for infinity.
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
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...
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
Column Cut Class.
Definition: OsiColCut.hpp:23
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever &quot;iteration&quot; mean to the solver...
virtual void setColUpper(int elementIndex, double elementValue)=0
Set a single column upper bound.
virtual void enableSimplexInterface(bool doingPrimal)
Enables normal operation of subsequent functions.
void gutsOfConstructor()
The real work of the constructor.
void freeColType()
frees colsize_ vector
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound The default implementation just invokes setRowLower() and set...
bool disableadvbasis
Whether to disable use of advanced basis (if given)
Base class for message handling.
row information: right hand sides, ranges and senses, lower and upper bounds for row ...
virtual bool isInteger(int colIndex) const
Return true if the variable is integer.
char * coltype_
Pointer to dense vector of variable types (continous, binary, integer)
CoinPackedMatrix * matrixByCol_
Pointer to row-wise copy of problem matrix coefficients.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)=0
Add a column (primal variable) to the problem.
Abstract Base Class for describing an interface to a solver.
virtual void branchAndBound()
Invoke solver&#39;s built-in enumeration algorithm.
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 bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -COIN_DBL_MAX for -infinity.
Abstract base class for various sparse vectors.
virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05) const
Get vector of indices of primal variables which are integer variables but have fractional values in t...
virtual ~OsiCpxSolverInterface()
Destructor.
void switchToLP()
switches CPLEX to prob type LP
double * redcost_
Pointer to reduced cost vector.
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows) ...
double * rowsol_
Pointer to dual solution vector.
friend void OsiCpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiCpxSolverInterface class.
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
double * colsol_
Pointer to primal solution vector.
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 void disableFactorization() const
Useless function, defined only for compatibility with OsiSimplexInterface.
struct cpxlp * CPXLPptr
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
virtual void deleteCols(const int num, const int *colIndices)
Remove a set of columns (primal variables) from the problem.
bool probtypemip_
Stores whether CPLEX&#39; prob type is currently set to MIP.
void gutsOfDestructor()
The real work of the destructor.
CPXENVptr getEnvironmentPtr()
Method to access CPLEX environment pointer.
virtual int canDoSimplexInterface() const
Returns 1 if can just do getBInv etc 2 if has all OsiSimplex methods and 0 if it has none...
int * hotStartCStat_
Hotstart information.
virtual void getBasics(int *index) const
Get indices of the pivot variable in each row (order of indices corresponds to the order of elements ...
CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
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 void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
CPXENVptr getMutableEnvironmentPtr() const
Get Environment Pointer for const methods.
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
void freeCachedData(int keepCached=KEEPCACHED_NONE)
free all cached data (except specified entries, see getLpPtr())
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.
virtual bool isBinary(int colIndex) const
Return true if the variable is binary.
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 const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound The default implementation just invokes setColLower() and ...
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (bound adjustment).
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use COIN_DBL_MAX for infinity.
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
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...
CPXENVptr env_
CPLEX environment used in this class instance.
virtual void reset()
Resets as if default constructor.
Row Cut Class.
Definition: OsiRowCut.hpp:29
CPXLPptr getLpPtr(int keepCached=KEEPCACHED_NONE)
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
free only cached column and LP solution information
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
Sparse Matrix Base Class.
OsiCpxSolverInterface & operator=(const OsiCpxSolverInterface &rhs)
Assignment operator.
virtual double getObjValue() const
Get objective function value.
CPLEX Solver Interface.
virtual void getBInvCol(int col, double *vec) const
Get a column of the basis inverse.
virtual void getBasisStatus(int *cstat, int *rstat) const
Returns a basis status of the structural/artificial variables At present as warm start i...
void resizeColType(int minsize)
resizes coltype_ vector to be able to store at least minsize elements
const char * getCtype() const
return a vector of variable types (continous, binary, integer)
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
virtual void markHotStart()
Create a hotstart point of the optimization process.
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
virtual bool isFreeBinary(int colIndex) const
Return true if the variable is binary and not fixed.
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
column information: objective values, lower and upper bounds, variable types
void switchToMIP()
switches CPLEX to prob type MIP
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut. Return true if cut was applied.
virtual void getBInvRow(int row, double *z) const
Get a row of the basis inverse.
virtual void resolve()
Resolve an LP relaxation after problem modification.
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
char * rowsense_
Pointer to dense vector of row sense indicators.
void freeCachedColRim()
free cached column rim vectors
virtual void enableSimplexInterface(int doingPrimal)
Useless function, defined only for compatibility with OsiSimplexInterface.
virtual void initialSolve()
Solve initial LP relaxation.
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
virtual void getBInvACol(int col, double *vec) const
Get a column of the tableau.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
virtual int getNumRows() const
Get number of rows.
double * colupper_
Pointer to dense vector of variable lower bounds.
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use COIN_DBL_MAX for infinity.
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)=0
Add a row (constraint) to the problem.
std::vector< int > OsiVectorInt
Vector of int.
virtual bool basisIsAvailable() const
Returns true if a basis is available.
int coltypesize_
Size of allocated memory for coltype_.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
void freeAllMemory()
free all allocated memory
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
free only cached row and LP solution information
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
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 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.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
Abstract base class for warm start information.
virtual int getNumCols() const
Get number of columns.
free only cached LP solution information
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.
double * rhs_
Pointer to dense vector of row right-hand side values.
double * rowact_
Pointer to row activity (slack) vector.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
Add a column (primal variable) to the problem.
struct cpxenv * CPXENVptr
double * obj_
Pointer to objective vector.
double * collower_
Pointer to dense vector of variable lower bounds.
bool setStrParam(OsiStrParam key, const std::string &value)
Set a string parameter.
void freeCachedResults()
free cached result vectors
keep all cached data (similar to getMutableLpPtr())