Osi  0.107.8
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 
34  //---------------------------------------------------------------------------
37  virtual void initialSolve();
39 
41  virtual void resolve();
42 
44  virtual void branchAndBound();
46 
47  //---------------------------------------------------------------------------
63  // Set an integer parameter
64  bool setIntParam(OsiIntParam key, int value);
65  // Set an double parameter
66  bool setDblParam(OsiDblParam key, double value);
67  // Set a string parameter
68  bool setStrParam(OsiStrParam key, const std::string & value);
69  // Get an integer parameter
70  bool getIntParam(OsiIntParam key, int& value) const;
71  // Get an double parameter
72  bool getDblParam(OsiDblParam key, double& value) const;
73  // Get a string parameter
74  bool getStrParam(OsiStrParam key, std::string& value) const;
75  // Set mipstart option (pass column solution to CPLEX before MIP start)
76  void setMipStart(bool value) { domipstart = value; }
77  // Get mipstart option value
78  bool getMipStart() const { return domipstart; }
80 
81  //---------------------------------------------------------------------------
83 
84  virtual bool isAbandoned() const;
87  virtual bool isProvenOptimal() const;
89  virtual bool isProvenPrimalInfeasible() const;
91  virtual bool isProvenDualInfeasible() const;
93  virtual bool isPrimalObjectiveLimitReached() const;
95  virtual bool isDualObjectiveLimitReached() const;
97  virtual bool isIterationLimitReached() const;
99 
100  //---------------------------------------------------------------------------
103 
110  CoinWarmStart *getEmptyWarmStart () const;
111 
113  virtual CoinWarmStart* getWarmStart() const;
116  virtual bool setWarmStart(const CoinWarmStart* warmstart);
118 
119  //---------------------------------------------------------------------------
126  virtual void markHotStart();
129  virtual void solveFromHotStart();
131  virtual void unmarkHotStart();
133 
134  //---------------------------------------------------------------------------
149  virtual int getNumCols() const;
151 
153  virtual int getNumRows() const;
154 
156  virtual int getNumElements() const;
157 
159  virtual const double * getColLower() const;
160 
162  virtual const double * getColUpper() const;
163 
173  virtual const char * getRowSense() const;
174 
183  virtual const double * getRightHandSide() const;
184 
193  virtual const double * getRowRange() const;
194 
196  virtual const double * getRowLower() const;
197 
199  virtual const double * getRowUpper() const;
200 
202  virtual const double * getObjCoefficients() const;
203 
205  virtual double getObjSense() const;
206 
208  virtual bool isContinuous(int colNumber) const;
209 
210 #if 0
211  virtual bool isBinary(int columnNumber) const;
213 
218  virtual bool isInteger(int columnNumber) const;
219 
221  virtual bool isIntegerNonBinary(int columnNumber) const;
222 
224  virtual bool isFreeBinary(int columnNumber) const;
225 #endif
226 
228  virtual const CoinPackedMatrix * getMatrixByRow() const;
229 
231  virtual const CoinPackedMatrix * getMatrixByCol() const;
232 
234  virtual double getInfinity() const;
236 
239  virtual const double * getColSolution() const;
241 
243  virtual const double * getRowPrice() const;
244 
246  virtual const double * getReducedCost() const;
247 
250  virtual const double * getRowActivity() const;
251 
253  virtual double getObjValue() const;
254 
257  virtual int getIterationCount() const;
258 
276  virtual std::vector<double*> getDualRays(int maxNumRays,
277  bool fullRay = false) const;
289  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
290 
291 #if 0
292 
294  virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
295  const;
296 #endif
297 
298 
299 
300  //---------------------------------------------------------------------------
301 
304  //-------------------------------------------------------------------------
308  virtual void setObjCoeff( int elementIndex, double elementValue );
309 
311  virtual void setObjCoeffSet(const int* indexFirst,
312  const int* indexLast,
313  const double* coeffList);
314 
318  virtual void setColLower( int elementIndex, double elementValue );
319 
323  virtual void setColUpper( int elementIndex, double elementValue );
324 
328  virtual void setColBounds( int elementIndex,
329  double lower, double upper );
330 
338  virtual void setColSetBounds(const int* indexFirst,
339  const int* indexLast,
340  const double* boundList);
341 
344  virtual void setRowLower( int elementIndex, double elementValue );
345 
348  virtual void setRowUpper( int elementIndex, double elementValue );
349 
353  virtual void setRowBounds( int elementIndex,
354  double lower, double upper );
355 
357  virtual void setRowType(int index, char sense, double rightHandSide,
358  double range);
359 
367  virtual void setRowSetBounds(const int* indexFirst,
368  const int* indexLast,
369  const double* boundList);
370 
380  virtual void setRowSetTypes(const int* indexFirst,
381  const int* indexLast,
382  const char* senseList,
383  const double* rhsList,
384  const double* rangeList);
386 
387  //-------------------------------------------------------------------------
391  virtual void setContinuous(int index);
393  virtual void setInteger(int index);
396  virtual void setContinuous(const int* indices, int len);
399  virtual void setInteger(const int* indices, int len);
401 
402  //-------------------------------------------------------------------------
404  virtual void setObjSense(double s);
405 
416  virtual void setColSolution(const double * colsol);
417 
428  virtual void setRowPrice(const double * rowprice);
429 
430  //-------------------------------------------------------------------------
437  virtual void addCol(const CoinPackedVectorBase& vec,
438  const double collb, const double colub,
439  const double obj);
440 
443  virtual void addCols(const int numcols,
444  const CoinPackedVectorBase * const * cols,
445  const double* collb, const double* colub,
446  const double* obj);
448  virtual void deleteCols(const int num, const int * colIndices);
449 
452  virtual void addRow(const CoinPackedVectorBase& vec,
453  const double rowlb, const double rowub);
455  virtual void addRow(const CoinPackedVectorBase& vec,
456  const char rowsen, const double rowrhs,
457  const double rowrng);
458 
461  virtual void addRows(const int numrows,
462  const CoinPackedVectorBase * const * rows,
463  const double* rowlb, const double* rowub);
465  virtual void addRows(const int numrows,
466  const CoinPackedVectorBase * const * rows,
467  const char* rowsen, const double* rowrhs,
468  const double* rowrng);
470  virtual void deleteRows(const int num, const int * rowIndices);
471 
472 #if 0
473  // ??? implemented in OsiSolverInterface
474  //-----------------------------------------------------------------------
496  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
497  double effectivenessLb = 0.0);
498 #endif
499 
500 
501 
502  //---------------------------------------------------------------------------
503 
517  virtual void loadProblem(const CoinPackedMatrix& matrix,
518  const double* collb, const double* colub,
519  const double* obj,
520  const double* rowlb, const double* rowub);
521 
529  virtual void assignProblem(CoinPackedMatrix*& matrix,
530  double*& collb, double*& colub, double*& obj,
531  double*& rowlb, double*& rowub);
532 
545  virtual void loadProblem(const CoinPackedMatrix& matrix,
546  const double* collb, const double* colub,
547  const double* obj,
548  const char* rowsen, const double* rowrhs,
549  const double* rowrng);
550 
558  virtual void assignProblem(CoinPackedMatrix*& matrix,
559  double*& collb, double*& colub, double*& obj,
560  char*& rowsen, double*& rowrhs,
561  double*& rowrng);
562 
565  virtual void loadProblem(const int numcols, const int numrows,
566  const int* start, const int* index,
567  const double* value,
568  const double* collb, const double* colub,
569  const double* obj,
570  const double* rowlb, const double* rowub);
571 
574  virtual void loadProblem(const int numcols, const int numrows,
575  const int* start, const int* index,
576  const double* value,
577  const double* collb, const double* colub,
578  const double* obj,
579  const char* rowsen, const double* rowrhs,
580  const double* rowrng);
581 
584  virtual int readMps(const char *filename,
585  const char *extension = "mps");
586 
591  virtual void writeMps(const char *filename,
592  const char *extension = "mps",
593  double objSense=0.0) const;
594 
596 
604  void passInMessageHandler(CoinMessageHandler * handler);
606 
607  //---------------------------------------------------------------------------
608 
615  {
638  };
639  CPXLPptr getLpPtr( int keepCached = KEEPCACHED_NONE );
640 
645 
647  const char* getCtype() const;
648 
653 
655  virtual OsiSolverInterface * clone(bool copyData = true) const;
656 
659 
662 
664  virtual ~OsiCpxSolverInterface();
665 
667  virtual void reset();
669 
670 /***************************************************************************/
690 
694  virtual int canDoSimplexInterface() const;
695 
700  virtual void enableSimplexInterface(int doingPrimal) {};
701 
705  virtual void disableSimplexInterface() {};
706 
710  virtual void enableFactorization() const {};
711 
715  virtual void disableFactorization() const {};
716 
718  virtual bool basisIsAvailable() const;
719 
723  virtual void getBasisStatus(int* cstat, int* rstat) const;
724 
726  virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
727 
729  virtual void getBInvRow(int row, double* z) const;
730 
732  virtual void getBInvACol(int col, double* vec) const;
733 
735  virtual void getBInvCol(int col, double* vec) const;
736 
742  virtual void getBasics(int* index) const;
744  void switchToLP();
745 
747  void switchToMIP();
748 
750 /***************************************************************************/
751 
752 protected:
753 
755  CPXLPptr getMutableLpPtr() const;
756 
759 
762  virtual void applyRowCut( const OsiRowCut & rc );
764 
768  virtual void applyColCut( const OsiColCut & cc );
770 
771 private:
774  void resizeColType( int minsize );
776 
778  void freeColType();
780 
781 
784 
786  void gutsOfCopy( const OsiCpxSolverInterface & source );
787 
789  void gutsOfConstructor();
790 
792  void gutsOfDestructor();
793 
795  void freeCachedColRim();
796 
798  void freeCachedRowRim();
799 
801  void freeCachedResults();
802 
804  void freeCachedMatrix();
805 
807  void freeCachedData( int keepCached = KEEPCACHED_NONE );
808 
810  void freeAllMemory();
811 
813 
814 
817  mutable CPXENVptr env_;
820  mutable CPXLPptr lp_;
821 
828 
831  mutable double *obj_;
833 
835  mutable double *collower_;
836 
838  mutable double *colupper_;
839 
841  mutable char *rowsense_;
842 
844  mutable double *rhs_;
845 
847  mutable double *rowrange_;
848 
850  mutable double *rowlower_;
851 
853  mutable double *rowupper_;
854 
856  mutable double *colsol_;
857 
859  mutable double *rowsol_;
860 
862  mutable double *redcost_;
863 
865  mutable double *rowact_;
866 
868  mutable CoinPackedMatrix *matrixByRow_;
869 
871  mutable CoinPackedMatrix *matrixByCol_;
873 
876  char *coltype_;
878 
881 
883  mutable bool probtypemip_;
884 
887 
890 
892 };
893 
894 //#############################################################################
896 void OsiCpxSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
897 
898 #endif
free only cached matrix and LP solution information
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
problem matrix: matrix ordered by column and by row
const char * getCtype() const
return a vector of variable types (continous, binary, integer)
virtual int readMps(const char *filename, const char *extension="mps")
Read a problem in MPS format from the given filename.
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
void freeCachedRowRim()
free cached row rim vectors
discard all cached data (default)
CPXLPptr getMutableLpPtr() const
Get LP Pointer for const methods.
keepCachedFlag
Get pointer to CPLEX model and free all specified cached data entries (combined with logical or-opera...
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
virtual bool basisIsAvailable() const
Returns true if a basis is available.
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective 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...
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)
CPXLPptr lp_
CPLEX model represented by this class instance.
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 bool isAbandoned() const
Are there a numerical difficulties?
bool domipstart
Whether to pass a column solution to CPLEX before starting MIP solve (copymipstart) ...
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
double * rowupper_
Pointer to dense vector of row upper bounds.
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.
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
CPXENVptr getMutableEnvironmentPtr() const
Get Environment Pointer for const methods.
virtual bool isFreeBinary(int colIndex) const
Return true if the variable is binary and not fixed.
virtual void unmarkHotStart()
Delete the snapshot.
OsiCpxSolverInterface()
Default Constructor.
virtual bool isIntegerNonBinary(int colIndex) const
Return true if the variable is general integer.
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 setObjCoeffSet(const int *indexFirst, const int *indexLast, const double *coeffList)
Set a a set of objective function coefficients.
CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
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 void getBInvCol(int col, double *vec) const
Get a column of the basis inverse.
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
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 double getObjSense() const
Get 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
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
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.
virtual int getNumRows() const
Get number of rows.
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)
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
row information: right hand sides, ranges and senses, lower and upper bounds for row ...
char * coltype_
Pointer to dense vector of variable types (continous, binary, integer)
CoinPackedMatrix * matrixByCol_
Pointer to row-wise copy of problem matrix coefficients.
virtual double getObjValue() const
Get objective function value.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)=0
Add a column (primal variable) to the problem.
virtual int getNumCols() const
Get number of columns.
virtual void getBInvACol(int col, double *vec) const
Get a column of the tableau.
Abstract Base Class for describing an interface to a solver.
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 void branchAndBound()
Invoke solver&#39;s built-in enumeration algorithm.
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
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 setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -COIN_DBL_MAX for -infinity.
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) ...
virtual bool isInteger(int colIndex) const
Return true if the variable is integer.
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.
double * colsol_
Pointer to primal solution vector.
virtual bool isProvenOptimal() const
Is optimality proven?
std::vector< int > OsiVectorInt
Vector of int.
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.
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.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
bool probtypemip_
Stores whether CPLEX&#39; prob type is currently set to MIP.
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
void gutsOfDestructor()
The real work of the destructor.
CPXENVptr getEnvironmentPtr()
Method to access CPLEX environment pointer.
int * hotStartCStat_
Hotstart information.
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.
virtual void getBInvARow(int row, double *z, double *slack=NULL) const
Get a row of the tableau (slack part in slack if not NULL)
virtual void enableFactorization() const
Useless function, defined only for compatibility with OsiSimplexInterface.
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 const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
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 getBasics(int *index) const
Get indices of the pivot variable in each row (order of indices corresponds to the order of elements ...
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
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.
virtual int canDoSimplexInterface() const
Returns 1 if can just do getBInv etc 2 if has all OsiSimplex methods and 0 if it has none...
Row Cut Class.
Definition: OsiRowCut.hpp:29
CPXLPptr getLpPtr(int keepCached=KEEPCACHED_NONE)
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
free only cached column and LP solution information
virtual void getBInvRow(int row, double *z) const
Get a row of the basis inverse.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever "iteration" mean to the solver...
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
OsiCpxSolverInterface & operator=(const OsiCpxSolverInterface &rhs)
Assignment operator.
CPLEX Solver Interface.
void resizeColType(int minsize)
resizes coltype_ vector to be able to store at least minsize elements
virtual void markHotStart()
Create a hotstart point of the optimization process.
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
column information: objective values, lower and upper bounds, variable types
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
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 bool isIterationLimitReached() const
Iteration limit reached?
virtual void resolve()
Resolve an LP relaxation after problem modification.
char * rowsense_
Pointer to dense vector of row sense indicators.
void freeCachedColRim()
free cached column rim vectors
virtual void disableFactorization() const
Useless function, defined only for compatibility with OsiSimplexInterface.
virtual void enableSimplexInterface(int doingPrimal)
Useless function, defined only for compatibility with OsiSimplexInterface.
virtual void initialSolve()
Solve initial LP relaxation.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
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 const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
virtual void getBasisStatus(int *cstat, int *rstat) const
Returns a basis status of the structural/artificial variables At present as warm start i...
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)=0
Add a row (constraint) to the problem.
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
virtual bool isBinary(int colIndex) const
Return true if the variable is binary.
int coltypesize_
Size of allocated memory for coltype_.
void freeAllMemory()
free all allocated memory
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 int getNumElements() const
Get number of nonzero elements.
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.
virtual double getInfinity() const
Get solver&#39;s value for infinity.
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())