Osi  0.108.6
OsiTestSolverInterface.hpp
Go to the documentation of this file.
1 // Copyright (C) 2000, International Business Machines
2 // Corporation and others. All Rights Reserved.
3 // This file is licensed under the terms of Eclipse Public License (EPL).
4 
5 // this is a copy of OsiVolSolverInterface (trunk rev. 1466) renamed to OsiTestSolverInterface
6 
7 #ifndef OsiTestSolverInterface_H
8 #define OsiTestSolverInterface_H
9 
10 #include <string>
11 
12 #include "OsiTestSolver.hpp"
13 
14 #include "CoinPackedMatrix.hpp"
15 
16 #include "OsiSolverInterface.hpp"
17 
18 static const double OsiTestInfinity = 1.0e31;
19 
20 //#############################################################################
21 
28  virtual public OsiSolverInterface, public VOL_user_hooks {
29  friend void OsiTestSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
30 
31 private:
33  int majorDim_;
34  int minorDim_;
35 
36  int plusSize_;
37  int * plusInd_;
38  int * plusStart_;
39  int * plusLength_;
40 
42  int * minusInd_;
43  int * minusStart_;
44  int * minusLength_;
45 
46  public:
47  OsiVolMatrixOneMinusOne_(const CoinPackedMatrix& m);
49  void timesMajor(const double* x, double* y) const;
50  };
51 
52 public:
53  //---------------------------------------------------------------------------
56  virtual void initialSolve();
58 
60  virtual void resolve();
61 
63  virtual void branchAndBound() {
64  throw CoinError("Sorry, the Volume Algorithm doesn't implement B&B",
65  "branchAndBound", "OsiTestSolverInterface");
66  }
68 
69  //---------------------------------------------------------------------------
85  // Set an integer parameter
86  bool setIntParam(OsiIntParam key, int value);
87  // Set an double parameter
88  bool setDblParam(OsiDblParam key, double value);
89  // Set a string parameter
90  bool setStrParam(OsiStrParam key, const std::string & value);
91  // Get an integer parameter
92  bool getIntParam(OsiIntParam key, int& value) const;
93  // Get an double parameter
94  bool getDblParam(OsiDblParam key, double& value) const;
95  // Get a string parameter
96  bool getStrParam(OsiStrParam key, std::string& value) const;
98 
99  //---------------------------------------------------------------------------
101 
102  virtual bool isAbandoned() const;
105  virtual bool isProvenOptimal() const;
107  virtual bool isProvenPrimalInfeasible() const;
109  virtual bool isProvenDualInfeasible() const;
111  virtual bool isPrimalObjectiveLimitReached() const;
113  virtual bool isDualObjectiveLimitReached() const;
115  virtual bool isIterationLimitReached() const;
117 
118  //---------------------------------------------------------------------------
127  virtual CoinWarmStart *getEmptyWarmStart () const ;
128 
130  virtual CoinWarmStart* getWarmStart() const;
133  virtual bool setWarmStart(const CoinWarmStart* warmstart);
135 
136  //---------------------------------------------------------------------------
143  virtual void markHotStart();
146  virtual void solveFromHotStart();
148  virtual void unmarkHotStart();
150 
151  //---------------------------------------------------------------------------
166  virtual int getNumCols() const {
168  return rowMatrixCurrent_?
169  rowMatrix_.getNumCols() : colMatrix_.getNumCols(); }
170 
172  virtual int getNumRows() const {
173  return rowMatrixCurrent_?
174  rowMatrix_.getNumRows() : colMatrix_.getNumRows(); }
175 
177  virtual int getNumElements() const {
178  return rowMatrixCurrent_?
179  rowMatrix_.getNumElements() : colMatrix_.getNumElements(); }
180 
182  virtual const double * getColLower() const { return collower_; }
183 
185  virtual const double * getColUpper() const { return colupper_; }
186 
196  virtual const char * getRowSense() const { return rowsense_; }
197 
206  virtual const double * getRightHandSide() const { return rhs_; }
207 
216  virtual const double * getRowRange() const { return rowrange_; }
217 
219  virtual const double * getRowLower() const { return rowlower_; }
220 
222  virtual const double * getRowUpper() const { return rowupper_; }
223 
225  virtual const double * getObjCoefficients() const { return objcoeffs_; }
226 
228  virtual double getObjSense() const { return objsense_; }
229 
231  virtual bool isContinuous(int colNumber) const;
232 
233 #if 0
235  virtual bool isBinary(int colNumber) const;
236 
241  virtual bool isInteger(int colNumber) const;
242 
244  virtual bool isIntegerNonBinary(int colNumber) const;
245 
247  virtual bool isFreeBinary(int colNumber) const;
248 #endif
249 
251  virtual const CoinPackedMatrix * getMatrixByRow() const;
252 
254  virtual const CoinPackedMatrix * getMatrixByCol() const;
255 
257  virtual double getInfinity() const { return OsiTestInfinity; }
259 
263  virtual const double * getColSolution() const { return colsol_; }
264 
266  virtual const double * getRowPrice() const { return rowprice_; }
267 
269  virtual const double * getReducedCost() const { return rc_; }
270 
273  virtual const double * getRowActivity() const { return lhs_; }
274 
276  virtual double getObjValue() const {
277 #if 1
278  // This does not pass unitTest if getObjValue is called before solve
279  return lagrangeanCost_;
280 #else
282 #endif
283  }
284 
287  virtual int getIterationCount() const { return volprob_.iter(); }
288 
306  virtual std::vector<double*> getDualRays(int maxNumRays,
307  bool fullRay = false) const;
319  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
320 
321 #if 0
324  virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
325  const;
326 #endif
328 
329 
330  //---------------------------------------------------------------------------
331 
334  //-------------------------------------------------------------------------
338  virtual void setObjCoeff( int elementIndex, double elementValue ) {
339  objcoeffs_[elementIndex] = elementValue;
340  }
341 
345  virtual void setColLower( int elementIndex, double elementValue ) {
346  collower_[elementIndex] = elementValue;
347  }
348 
352  virtual void setColUpper( int elementIndex, double elementValue ) {
353  colupper_[elementIndex] = elementValue;
354  }
355 
357  virtual void setColBounds( int elementIndex,
358  double lower, double upper ) {
359  collower_[elementIndex] = lower;
360  colupper_[elementIndex] = upper;
361  }
362 
371  virtual void setColSetBounds(const int* indexFirst,
372  const int* indexLast,
373  const double* boundList);
374 
377  virtual void setRowLower( int elementIndex, double elementValue ) {
378  rowlower_[elementIndex] = elementValue;
379  convertBoundToSense(elementValue, rowupper_[elementIndex],
380  rowsense_[elementIndex], rhs_[elementIndex],
381  rowrange_[elementIndex]);
382  }
383 
386  virtual void setRowUpper( int elementIndex, double elementValue ) {
387  rowupper_[elementIndex] = elementValue;
388  convertBoundToSense(rowlower_[elementIndex], elementValue,
389  rowsense_[elementIndex], rhs_[elementIndex],
390  rowrange_[elementIndex]);
391  }
392 
394  virtual void setRowBounds( int elementIndex,
395  double lower, double upper ) {
396  rowlower_[elementIndex] = lower;
397  rowupper_[elementIndex] = upper;
398  convertBoundToSense(lower, upper,
399  rowsense_[elementIndex], rhs_[elementIndex],
400  rowrange_[elementIndex]);
401  }
402 
404  virtual void setRowType(int index, char sense, double rightHandSide,
405  double range) {
406  rowsense_[index] = sense;
407  rhs_[index] = rightHandSide;
408  rowrange_[index] = range;
409  convertSenseToBound(sense, rightHandSide, range,
410  rowlower_[index], rowupper_[index]);
411  }
412 
421  virtual void setRowSetBounds(const int* indexFirst,
422  const int* indexLast,
423  const double* boundList);
424 
435  virtual void setRowSetTypes(const int* indexFirst,
436  const int* indexLast,
437  const char* senseList,
438  const double* rhsList,
439  const double* rangeList);
441 
442  //-------------------------------------------------------------------------
446  virtual void setContinuous(int index);
448  virtual void setInteger(int index);
451  virtual void setContinuous(const int* indices, int len);
454  virtual void setInteger(const int* indices, int len);
456 
457  //-------------------------------------------------------------------------
459  virtual void setObjSense(double s ) { objsense_ = s < 0 ? -1.0 : 1.0; }
460 
471  virtual void setColSolution(const double * colsol);
472 
483  virtual void setRowPrice(const double * rowprice);
484 
485  //-------------------------------------------------------------------------
490 
493  virtual void addCol(const CoinPackedVectorBase& vec,
494  const double collb, const double colub,
495  const double obj);
496 
499  virtual void addCols(const int numcols,
500  const CoinPackedVectorBase * const * cols,
501  const double* collb, const double* colub,
502  const double* obj);
503 #if 0
505  virtual void addCols(const CoinPackedMatrix& matrix,
506  const double* collb, const double* colub,
507  const double* obj);
508 #endif
510  virtual void deleteCols(const int num, const int * colIndices);
511 
514  virtual void addRow(const CoinPackedVectorBase& vec,
515  const double rowlb, const double rowub);
517  virtual void addRow(const CoinPackedVectorBase& vec,
518  const char rowsen, const double rowrhs,
519  const double rowrng);
520 
523  virtual void addRows(const int numrows,
524  const CoinPackedVectorBase * const * rows,
525  const double* rowlb, const double* rowub);
527  virtual void addRows(const int numrows,
528  const CoinPackedVectorBase * const * rows,
529  const char* rowsen, const double* rowrhs,
530  const double* rowrng);
531 #if 0
533  virtual void addRows(const CoinPackedMatrix& matrix,
534  const double* rowlb, const double* rowub);
536  virtual void addRows(const CoinPackedMatrix& matrix,
537  const char* rowsen, const double* rowrhs,
538  const double* rowrng);
539 #endif
541  virtual void deleteRows(const int num, const int * rowIndices);
542 
543  //-----------------------------------------------------------------------
544 #if 0
566  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
567  double effectivenessLb = 0.0);
568 #endif
570 
571 
572  //---------------------------------------------------------------------------
573 
574 protected:
576  void initFromRlbRub(const int rownum,
577  const double* rowlb, const double* rowub);
578  void initFromRhsSenseRange(const int rownum, const char* rowsen,
579  const double* rowrhs, const double* rowrng);
580  void initFromClbCubObj(const int colnum, const double* collb,
581  const double* colub, const double* obj);
582 public:
583 
597  virtual void loadProblem(const CoinPackedMatrix& matrix,
598  const double* collb, const double* colub,
599  const double* obj,
600  const double* rowlb, const double* rowub);
601 
609  virtual void assignProblem(CoinPackedMatrix*& matrix,
610  double*& collb, double*& colub, double*& obj,
611  double*& rowlb, double*& rowub);
612 
625  virtual void loadProblem(const CoinPackedMatrix& matrix,
626  const double* collb, const double* colub,
627  const double* obj,
628  const char* rowsen, const double* rowrhs,
629  const double* rowrng);
630 
638  virtual void assignProblem(CoinPackedMatrix*& matrix,
639  double*& collb, double*& colub, double*& obj,
640  char*& rowsen, double*& rowrhs,
641  double*& rowrng);
642 
645  virtual void loadProblem(const int numcols, const int numrows,
646  const int* start, const int* index,
647  const double* value,
648  const double* collb, const double* colub,
649  const double* obj,
650  const double* rowlb, const double* rowub);
651 
654  virtual void loadProblem(const int numcols, const int numrows,
655  const int* start, const int* index,
656  const double* value,
657  const double* collb, const double* colub,
658  const double* obj,
659  const char* rowsen, const double* rowrhs,
660  const double* rowrng);
661 
664  virtual int readMps(const char *filename,
665  const char *extension = "mps");
666 
671  virtual void writeMps(const char *filename,
672  const char *extension = "mps",
673  double objSense=0.0) const;
675 
676  //---------------------------------------------------------------------------
677 
681  VOL_problem* volprob() { return &volprob_; }
683 
684  //---------------------------------------------------------------------------
685 
690 
692  virtual OsiSolverInterface * clone(bool copyData = true) const;
693 
696 
699 
703 
704  //---------------------------------------------------------------------------
705 
706 protected:
708 
709 
710  virtual void applyRowCut(const OsiRowCut& rc);
711 
713  virtual void applyColCut(const OsiColCut& cc);
715 
716  //---------------------------------------------------------------------------
717 
718 private:
722  virtual int compute_rc(const VOL_dvector& u, VOL_dvector& rc);
724  virtual int solve_subproblem(const VOL_dvector& dual,
725  const VOL_dvector& rc,
726  double& lcost, VOL_dvector& x, VOL_dvector& v,
727  double& pcost);
730  virtual int heuristics(const VOL_problem& /*p*/,
731  const VOL_dvector& /*x*/, double& heur_val) {
732  heur_val = COIN_DBL_MAX;
733  return 0;
734  }
736 
737  //---------------------------------------------------------------------------
738 
739 private:
743  void updateRowMatrix_() const;
745  void updateColMatrix_() const;
746 
749  void checkData_() const;
752  void compute_rc_(const double* u, double* rc) const;
755 
762 
764  void rowRimResize_(const int newSize);
766  void colRimResize_(const int newSize);
767 
772 
774  bool test_zero_one_minusone_(const CoinPackedMatrix& m) const;
776 
777  //---------------------------------------------------------------------------
778 
779 private:
780 
781  //---------------------------------------------------------------------------
785  mutable bool rowMatrixCurrent_;
788  mutable CoinPackedMatrix rowMatrix_;
790  mutable bool colMatrixCurrent_;
792  mutable CoinPackedMatrix colMatrix_;
794 
795  //---------------------------------------------------------------------------
798  bool isZeroOneMinusOne_;
805 
806  //---------------------------------------------------------------------------
809  double *colupper_;
812  double *collower_;
814  bool *continuous_;
816  double *rowupper_;
818  double *rowlower_;
820  char *rowsense_;
822  double *rhs_;
825  double *rowrange_;
827  double *objcoeffs_;
829 
830  //---------------------------------------------------------------------------
832  double objsense_;
833 
834  //---------------------------------------------------------------------------
837  double *colsol_;
840  double *rowprice_;
842  double *rc_;
844  double *lhs_;
848 
849  //---------------------------------------------------------------------------
853 
858 
861 };
862 
864 void
865 OsiTestSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
866 
867 #endif
std::vector< int > OsiVectorInt
Vector of int.
static const double OsiTestInfinity
void OsiTestSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiTestSolverInterface class.
Column Cut Class.
Definition: OsiColCut.hpp:23
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
Row Cut Class.
Definition: OsiRowCut.hpp:29
Internal class for obtaining status from the applyCuts method.
Abstract Base Class for describing an interface to a solver.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)=0
Add a column (primal variable) to the problem.
void convertSenseToBound(const char sense, const double right, const double range, double &lower, double &upper) const
A quick inlined function to convert from the sense/rhs/range style of constraint definition to the lb...
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 addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)=0
Add a row (constraint) to the problem.
virtual bool isFreeBinary(int colIndex) const
Return true if the variable is binary and not fixed.
virtual bool isIntegerNonBinary(int colIndex) const
Return true if the variable is general integer.
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 ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
virtual bool isBinary(int colIndex) const
Return true if the variable is binary.
virtual void setColLower(int elementIndex, double elementValue)=0
Set a single column lower bound.
virtual double getObjValue() const =0
Get the objective function value.
virtual void setColUpper(int elementIndex, double elementValue)=0
Set a single column upper bound.
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 readMps(const char *filename, const char *extension="mps")
Read a problem in MPS format from the given filename.
virtual bool isInteger(int colIndex) const
Return true if the variable is integer.
void convertBoundToSense(const double lower, const double upper, char &sense, double &right, double &range) const
A quick inlined function to convert from the lb/ub style of constraint definition to the sense/rhs/ra...
void timesMajor(const double *x, double *y) const
OsiVolMatrixOneMinusOne_(const CoinPackedMatrix &m)
Vol(ume) Solver Interface.
virtual void deleteCols(const int num, const int *colIndices)
Remove a set of columns (primal variables) from the problem.
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.
virtual void markHotStart()
Create a hotstart point of the optimization process.
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
double lagrangeanCost_
The Lagrangean cost, a lower bound on the objective value.
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (adjust one or more bounds).
void colRimResize_(const int newSize)
Reallocate the rim arrays corresponding to the columns.
double * collower_
Pointer to dense vector of structural variable lower bounds.
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
double * colsol_
Pointer to dense vector of primal structural variable values.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
Add a column (primal variable) to the problem.
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
char * rowsense_
Pointer to dense vector of row sense indicators.
virtual void addRow(const CoinPackedVectorBase &vec, const char rowsen, const double rowrhs, const double rowrng)
Add a row (constraint) to the problem.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
bool isZeroOneMinusOne_
An indicator whether the matrix is 0/1/-1.
double * rowlower_
Pointer to dense vector of slack variable lower bounds.
void checkData_() const
Test whether the Volume Algorithm can be applied to the given problem.
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
double * rowprice_
Pointer to dense vector of dual row variable values.
virtual void branchAndBound()
Invoke solver'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...
OsiTestSolverInterface & operator=(const OsiTestSolverInterface &rhs)
Assignment operator.
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const char *rowsen, const double *rowrhs, const double *rowrng)
Add a set of rows (constraints) to the problem.
virtual int compute_rc(const VOL_dvector &u, VOL_dvector &rc)
compute reduced costs
virtual bool isProvenOptimal() const
Is optimality proven?
void updateRowMatrix_() const
Update the row ordered matrix from the column ordered one.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
OsiTestSolverInterface(const OsiTestSolverInterface &)
Copy constructor.
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut (append to constraint matrix).
double * colupper_
Pointer to dense vector of structural variable upper bounds.
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
virtual CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
OsiTestSolverInterface()
Default Constructor.
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
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...
CoinPackedMatrix rowMatrix_
The problem matrix in a row ordered form.
void convertBoundsToSenses_()
For each row convert LB/UB style row constraints to sense/rhs style.
double * rowpriceHotStart_
An array to store the hotstart information between solveHotStart() calls.
virtual int getNumCols() const
Get number of columns.
bool test_zero_one_minusone_(const CoinPackedMatrix &m) const
test whether the given matrix is 0/1/-1 entries only.
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 setContinuous(const int *indices, int len)
Set the variables listed in indices (which is of length len) to be continuous variables.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
int maxNumcols_
allocated size of the column related rim vectors
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...
double * objcoeffs_
Pointer to dense vector of objective coefficients.
void compute_rc_(const double *u, double *rc) const
Compute the reduced costs (rc) with respect to the dual values given in u.
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
virtual void loadProblem(const int numcols, const int numrows, const int *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 ...
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
OsiVolMatrixOneMinusOne_ * rowMatrixOneMinusOne_
The row ordered matrix without the elements.
virtual int heuristics(const VOL_problem &, const VOL_dvector &, double &heur_val)
Starting from the primal vector x, run a heuristic to produce an integer solution.
bool colMatrixCurrent_
A flag indicating whether the column ordered matrix is up-to-date.
virtual int getNumElements() const
Get number of nonzero elements.
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()...
bool * continuous_
Pointer to dense vector of bool to indicate if column is continuous.
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 * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
virtual void initialSolve()
Solve initial LP relaxation.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
void updateColMatrix_() const
Update the column ordered matrix from the row ordered one.
virtual bool isIterationLimitReached() const
Iteration limit reached?
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
bool setStrParam(OsiStrParam key, const std::string &value)
Set a string parameter.
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...
int maxNumrows_
allocated size of the row related rim vectors
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -COIN_DBL_MAX for -infinity.
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever "iteration" mean to the solver.
double * rowupper_
Pointer to dense vector of slack variable upper bounds.
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
virtual ~OsiTestSolverInterface()
Destructor.
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -COIN_DBL_MAX for -infinity.
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
virtual int getNumRows() const
Get number of rows.
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
double objsense_
Sense of objective (1 for min; -1 for max)
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
virtual double getInfinity() const
Get solver's value for infinity.
double * rhs_
Pointer to dense vector of row right-hand side values.
OsiVolMatrixOneMinusOne_ * colMatrixOneMinusOne_
The column ordered matrix without the elements.
VOL_problem * volprob()
Get pointer to Vol model.
void colRimAllocator_()
A method allocating sufficient space for the rim vectors corresponding to the columns.
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use COIN_DBL_MAX for infinity.
double * rc_
Pointer to dense vector of reduced costs.
virtual bool isAbandoned() const
Are there a numerical difficulties?
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 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 const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use COIN_DBL_MAX for infinity.
virtual void unmarkHotStart()
Delete the snapshot.
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
virtual int solve_subproblem(const VOL_dvector &dual, const VOL_dvector &rc, double &lcost, VOL_dvector &x, VOL_dvector &v, double &pcost)
Solve the subproblem for the subgradient step.
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
VOL_problem volprob_
The volume solver.
void initFromRhsSenseRange(const int rownum, const char *rowsen, const double *rowrhs, const double *rowrng)
CoinPackedMatrix colMatrix_
The problem matrix in a column ordered form.
void gutsOfDestructor_()
A method deleting every member data.
friend void OsiTestSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiTestSolverInterface class.
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows).
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
virtual void resolve()
Resolve an LP relaxation after problem modification.
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 getObjValue() const
Get objective function value.
double * lhs_
Pointer to dense vector of left hand sides (row activity levels)
void rowRimResize_(const int newSize)
Reallocate the rim arrays corresponding to the rows.
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 rowRimAllocator_()
A method allocating sufficient space for the rim vectors corresponding to the rows.
virtual void loadProblem(const int numcols, const int numrows, const int *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 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 double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
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...
void initFromClbCubObj(const int colnum, const double *collb, const double *colub, const double *obj)
void convertSensesToBounds_()
For each row convert sense/rhs style row constraints to LB/UB style.
bool rowMatrixCurrent_
A flag indicating whether the row ordered matrix is up-to-date.
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
void initFromRlbRub(const int rownum, const double *rowlb, const double *rowub)
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
vector of doubles.
This class holds every data for the Volume Algorithm and its solve method must be invoked to solve th...
int iter() const
returns the iteration number
The user hooks should be overridden by the user to provide the problem specific routines for the volu...