Vol  1.5.4
OsiVolSolverInterface.hpp
Go to the documentation of this file.
1 // $Id$
2 // Copyright (C) 2000, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 
7 #ifndef OsiVolSolverInterface_H
8 #define OsiVolSolverInterface_H
9 
10 #include <string>
11 
12 #include "VolVolume.hpp"
13 
14 #include "CoinPackedMatrix.hpp"
15 
16 #include "OsiSolverInterface.hpp"
17 
18 static const double OsiVolInfinity = 1.0e31;
19 
20 //#############################################################################
21 
28  virtual public OsiSolverInterface, public VOL_user_hooks {
29  friend void OsiVolSolverInterfaceUnitTest(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", "OsiVolSolverInterface");
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
234  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 OsiVolInfinity; }
259 
262  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
281  return OsiSolverInterface::getObjValue();
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
322 
324  virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
325  const;
326 #endif
327 
328 
329 
330  //---------------------------------------------------------------------------
331 
334  //-------------------------------------------------------------------------
338  virtual void setObjCoeff( int elementIndex, double elementValue ) {
339  objcoeffs_[elementIndex] = elementValue;
340  }
341 
342  using OsiSolverInterface::setColLower ;
345  virtual void setColLower( int elementIndex, double elementValue ) {
346  collower_[elementIndex] = elementValue;
347  }
348 
349  using OsiSolverInterface::setColUpper ;
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 
491  using OsiSolverInterface::addCol ;
493  virtual void addCol(const CoinPackedVectorBase& vec,
494  const double collb, const double colub,
495  const double obj);
496 
497  using OsiSolverInterface::addCols ;
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
504 
505  virtual void addCols(const CoinPackedMatrix& matrix,
506  const double* collb, const double* colub,
507  const double* obj);
508 #endif
509 
510  virtual void deleteCols(const int num, const int * colIndices);
511 
512  using OsiSolverInterface::addRow ;
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 
521  using OsiSolverInterface::addRows ;
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
532 
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
540 
541  virtual void deleteRows(const int num, const int * rowIndices);
542 
543  //-----------------------------------------------------------------------
544 #if 0
545 
566  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
567  double effectivenessLb = 0.0);
568 #endif
569 
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 
662  using OsiSolverInterface::readMps ;
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 
680  VOL_problem* volprob() { return &volprob_; }
683 
684  //---------------------------------------------------------------------------
685 
690 
692  virtual OsiSolverInterface * clone(bool copyData = true) const;
693 
696 
699 
701  virtual ~OsiVolSolverInterface ();
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:
721  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 = 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;
754  void gutsOfDestructor_();
755 
758  void rowRimAllocator_();
761  void colRimAllocator_();
762 
764  void rowRimResize_(const int newSize);
766  void colRimResize_(const int newSize);
767 
769  void convertBoundsToSenses_();
771  void convertSensesToBounds_();
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 
863 //#############################################################################
865 void OsiVolSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
866 
867 #endif
OsiVolSolverInterface::setInteger
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
VOL_dvector
vector of doubles.
Definition: VolVolume.hpp:148
OsiVolSolverInterface::initFromRhsSenseRange
void initFromRhsSenseRange(const int rownum, const char *rowsen, const double *rowrhs, const double *rowrng)
OsiVolSolverInterface::resolve
virtual void resolve()
Resolve an LP relaxation after problem modification.
OsiVolSolverInterface::solveFromHotStart
virtual void solveFromHotStart()
Optimize starting from the hotstart.
OsiVolSolverInterface::addRows
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
OsiVolSolverInterface::setIntParam
bool setIntParam(OsiIntParam key, int value)
OsiVolSolverInterface::getRowSense
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
Definition: OsiVolSolverInterface.hpp:196
OsiVolSolverInterface::setRowBounds
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
Definition: OsiVolSolverInterface.hpp:394
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::plusStart_
int * plusStart_
Definition: OsiVolSolverInterface.hpp:38
OsiVolSolverInterface::isZeroOneMinusOne_
bool isZeroOneMinusOne_
An indicator whether the matrix is 0/1/-1.
Definition: OsiVolSolverInterface.hpp:799
VOL_problem::iter
int iter() const
returns the iteration number
Definition: VolVolume.hpp:681
OsiVolSolverInterface::setColBounds
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
Definition: OsiVolSolverInterface.hpp:357
OsiVolSolverInterface::lagrangeanCost_
double lagrangeanCost_
The Lagrangean cost, a lower bound on the objective value.
Definition: OsiVolSolverInterface.hpp:846
OsiVolSolverInterface::~OsiVolSolverInterface
virtual ~OsiVolSolverInterface()
Destructor.
OsiVolSolverInterface::setContinuous
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
OsiVolSolverInterface::getObjValue
virtual double getObjValue() const
Get objective function value.
Definition: OsiVolSolverInterface.hpp:276
OsiVolSolverInterface::applyRowCut
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut (append to constraint matrix).
OsiVolSolverInterface::colRimAllocator_
void colRimAllocator_()
A method allocating sufficient space for the rim vectors corresponding to the columns.
OsiVolSolverInterface::readMps
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
VOL_problem
This class holds every data for the Volume Algorithm and its solve method must be invoked to solve th...
Definition: VolVolume.hpp:605
OsiVolSolverInterface::isAbandoned
virtual bool isAbandoned() const
Are there a numerical difficulties?
OsiVolSolverInterface::getStrParam
bool getStrParam(OsiStrParam key, std::string &value) const
OsiVolSolverInterface::writeMps
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.
OsiVolSolverInterface::compute_rc
virtual int compute_rc(const VOL_dvector &u, VOL_dvector &rc)
compute reduced costs
OsiVolSolverInterface::lhs_
double * lhs_
Pointer to dense vector of left hand sides (row activity levels)
Definition: OsiVolSolverInterface.hpp:844
OsiVolSolverInterface::setDblParam
bool setDblParam(OsiDblParam key, double value)
OsiVolSolverInterface::initFromRlbRub
void initFromRlbRub(const int rownum, const double *rowlb, const double *rowub)
OsiVolSolverInterface::setRowSetBounds
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...
OsiVolSolverInterface::getRowRange
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
Definition: OsiVolSolverInterface.hpp:216
OsiVolSolverInterface::setObjCoeff
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
Definition: OsiVolSolverInterface.hpp:338
OsiVolSolverInterface::assignProblem
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...
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::plusSize_
int plusSize_
Definition: OsiVolSolverInterface.hpp:36
OsiVolSolverInterface::getDblParam
bool getDblParam(OsiDblParam key, double &value) const
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_
Definition: OsiVolSolverInterface.hpp:32
OsiVolSolverInterface::rowMatrix_
CoinPackedMatrix rowMatrix_
The problem matrix in a row ordered form.
Definition: OsiVolSolverInterface.hpp:788
OsiVolSolverInterface::getRowPrice
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
Definition: OsiVolSolverInterface.hpp:266
OsiVolSolverInterface::volprob
VOL_problem * volprob()
Get pointer to Vol model.
Definition: OsiVolSolverInterface.hpp:681
OsiVolSolverInterface::getMatrixByCol
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
OsiVolSolverInterface::checkData_
void checkData_() const
Test whether the Volume Algorithm can be applied to the given problem.
OsiVolSolverInterface::initFromClbCubObj
void initFromClbCubObj(const int colnum, const double *collb, const double *colub, const double *obj)
OsiVolSolverInterface::gutsOfDestructor_
void gutsOfDestructor_()
A method deleting every member data.
OsiVolSolverInterface::convertBoundsToSenses_
void convertBoundsToSenses_()
For each row convert LB/UB style row constraints to sense/rhs style.
OsiVolSolverInterface::isContinuous
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
OsiVolSolverInterface::getWarmStart
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
OsiVolSolverInterface::setRowLower
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
Definition: OsiVolSolverInterface.hpp:377
OsiVolSolverInterface::loadProblem
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...
OsiVolSolverInterface::updateRowMatrix_
void updateRowMatrix_() const
Update the row ordered matrix from the column ordered one.
OsiVolSolverInterface::getNumCols
virtual int getNumCols() const
Get number of columns.
Definition: OsiVolSolverInterface.hpp:167
OsiVolSolverInterface::solve_subproblem
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.
OsiVolSolverInterface::getRowActivity
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
Definition: OsiVolSolverInterface.hpp:273
OsiVolSolverInterface::getColUpper
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
Definition: OsiVolSolverInterface.hpp:185
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::minorDim_
int minorDim_
Definition: OsiVolSolverInterface.hpp:34
OsiVolSolverInterface::colMatrixOneMinusOne_
OsiVolMatrixOneMinusOne_ * colMatrixOneMinusOne_
The column ordered matrix without the elements.
Definition: OsiVolSolverInterface.hpp:803
OsiVolSolverInterface::compute_rc_
void compute_rc_(const double *u, double *rc) const
Compute the reduced costs (rc) with respect to the dual values given in u.
OsiVolSolverInterface::volprob_
VOL_problem volprob_
The volume solver.
Definition: OsiVolSolverInterface.hpp:860
OsiVolSolverInterface::rowlower_
double * rowlower_
Pointer to dense vector of slack variable lower bounds.
Definition: OsiVolSolverInterface.hpp:818
VOL_user_hooks
The user hooks should be overridden by the user to provide the problem specific routines for the volu...
Definition: VolVolume.hpp:563
OsiVolSolverInterface::setStrParam
bool setStrParam(OsiStrParam key, const std::string &value)
OsiVolSolverInterface::initialSolve
virtual void initialSolve()
Solve initial LP relaxation.
OsiVolSolverInterface::rowsense_
char * rowsense_
Pointer to dense vector of row sense indicators.
Definition: OsiVolSolverInterface.hpp:820
OsiVolSolverInterface::addRow
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
OsiVolSolverInterface::getObjSense
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
Definition: OsiVolSolverInterface.hpp:228
OsiVolSolverInterface::OsiVolSolverInterfaceUnitTest
friend void OsiVolSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiVolSolverInterface class.
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::plusLength_
int * plusLength_
Definition: OsiVolSolverInterface.hpp:39
OsiVolSolverInterface::deleteRows
virtual void deleteRows(const int num, const int *rowIndices)
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::majorDim_
int majorDim_
Definition: OsiVolSolverInterface.hpp:33
OsiVolSolverInterface::colupper_
double * colupper_
Pointer to dense vector of structural variable upper bounds.
Definition: OsiVolSolverInterface.hpp:810
OsiVolSolverInterface::test_zero_one_minusone_
bool test_zero_one_minusone_(const CoinPackedMatrix &m) const
test whether the given matrix is 0/1/-1 entries only.
OsiVolInfinity
static const double OsiVolInfinity
Definition: OsiVolSolverInterface.hpp:18
OsiVolSolverInterface::continuous_
bool * continuous_
Pointer to dense vector of bool to indicate if column is continuous.
Definition: OsiVolSolverInterface.hpp:814
OsiVolSolverInterface::rowprice_
double * rowprice_
Pointer to dense vector of dual row variable values.
Definition: OsiVolSolverInterface.hpp:840
OsiVolSolverInterface::rowrange_
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows).
Definition: OsiVolSolverInterface.hpp:825
OsiVolSolverInterface::colMatrixCurrent_
bool colMatrixCurrent_
A flag indicating whether the column ordered matrix is up-to-date.
Definition: OsiVolSolverInterface.hpp:790
OsiVolSolverInterface::setColLower
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
Definition: OsiVolSolverInterface.hpp:345
OsiVolSolverInterface::OsiVolSolverInterface
OsiVolSolverInterface()
Default Constructor.
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::minusSize_
int minusSize_
Definition: OsiVolSolverInterface.hpp:41
OsiVolSolverInterface::setColSolution
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
OsiVolSolverInterface::getReducedCost
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
Definition: OsiVolSolverInterface.hpp:269
OsiVolSolverInterface::setColUpper
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
Definition: OsiVolSolverInterface.hpp:352
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::OsiVolMatrixOneMinusOne_
OsiVolMatrixOneMinusOne_(const CoinPackedMatrix &m)
OsiVolSolverInterface::applyColCut
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (adjust one or more bounds).
OsiVolSolverInterface::rowMatrixOneMinusOne_
OsiVolMatrixOneMinusOne_ * rowMatrixOneMinusOne_
The row ordered matrix without the elements.
Definition: OsiVolSolverInterface.hpp:801
OsiVolSolverInterface::getRightHandSide
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
Definition: OsiVolSolverInterface.hpp:206
OsiVolSolverInterface::objcoeffs_
double * objcoeffs_
Pointer to dense vector of objective coefficients.
Definition: OsiVolSolverInterface.hpp:827
OsiVolSolverInterface::convertSensesToBounds_
void convertSensesToBounds_()
For each row convert sense/rhs style row constraints to LB/UB style.
OsiVolSolverInterface::getRowLower
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
Definition: OsiVolSolverInterface.hpp:219
OsiVolSolverInterface::colMatrix_
CoinPackedMatrix colMatrix_
The problem matrix in a column ordered form.
Definition: OsiVolSolverInterface.hpp:792
OsiVolSolverInterface::setObjSense
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
Definition: OsiVolSolverInterface.hpp:459
OsiVolSolverInterface::addCol
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
OsiVolSolverInterface::setRowSetTypes
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()...
OsiVolSolverInterface::getIterationCount
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever "iteration" mean to the solver.
Definition: OsiVolSolverInterface.hpp:287
OsiVolSolverInterface::rowRimAllocator_
void rowRimAllocator_()
A method allocating sufficient space for the rim vectors corresponding to the rows.
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::minusInd_
int * minusInd_
Definition: OsiVolSolverInterface.hpp:42
OsiVolSolverInterface::getColSolution
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
Definition: OsiVolSolverInterface.hpp:263
OsiVolSolverInterface::isIterationLimitReached
virtual bool isIterationLimitReached() const
Iteration limit reached?
OsiVolSolverInterface::isProvenDualInfeasible
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
OsiVolSolverInterface::getRowUpper
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
Definition: OsiVolSolverInterface.hpp:222
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::~OsiVolMatrixOneMinusOne_
~OsiVolMatrixOneMinusOne_()
OsiVolSolverInterface::getNumElements
virtual int getNumElements() const
Get number of nonzero elements.
Definition: OsiVolSolverInterface.hpp:177
OsiVolSolverInterface::setRowUpper
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
Definition: OsiVolSolverInterface.hpp:386
OsiVolSolverInterface::getObjCoefficients
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
Definition: OsiVolSolverInterface.hpp:225
OsiVolSolverInterface::rowRimResize_
void rowRimResize_(const int newSize)
Reallocate the rim arrays corresponding to the rows.
OsiVolSolverInterface::getNumRows
virtual int getNumRows() const
Get number of rows.
Definition: OsiVolSolverInterface.hpp:172
OsiVolSolverInterface::unmarkHotStart
virtual void unmarkHotStart()
Delete the snapshot.
OsiVolSolverInterface::getDualRays
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
OsiVolSolverInterface::markHotStart
virtual void markHotStart()
Create a hotstart point of the optimization process.
OsiVolSolverInterface::setRowType
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
Definition: OsiVolSolverInterface.hpp:404
OsiVolSolverInterface::branchAndBound
virtual void branchAndBound()
Invoke solver's built-in enumeration algorithm.
Definition: OsiVolSolverInterface.hpp:63
OsiVolSolverInterface::setWarmStart
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
OsiVolSolverInterface::updateColMatrix_
void updateColMatrix_() const
Update the column ordered matrix from the row ordered one.
OsiVolSolverInterface::maxNumrows_
int maxNumrows_
allocated size of the row related rim vectors
Definition: OsiVolSolverInterface.hpp:855
OsiVolSolverInterface::getEmptyWarmStart
virtual CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::minusLength_
int * minusLength_
Definition: OsiVolSolverInterface.hpp:44
OsiVolSolverInterface::getColLower
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
Definition: OsiVolSolverInterface.hpp:182
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::plusInd_
int * plusInd_
Definition: OsiVolSolverInterface.hpp:37
OsiVolSolverInterface::maxNumcols_
int maxNumcols_
allocated size of the column related rim vectors
Definition: OsiVolSolverInterface.hpp:857
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::minusStart_
int * minusStart_
Definition: OsiVolSolverInterface.hpp:43
VolVolume.hpp
OsiVolSolverInterface::isDualObjectiveLimitReached
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
OsiVolSolverInterface::collower_
double * collower_
Pointer to dense vector of structural variable lower bounds.
Definition: OsiVolSolverInterface.hpp:812
OsiVolSolverInterface::clone
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
OsiVolSolverInterface::heuristics
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.
Definition: OsiVolSolverInterface.hpp:730
OsiVolSolverInterface::setRowPrice
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
OsiVolSolverInterface::deleteCols
virtual void deleteCols(const int num, const int *colIndices)
OsiVolSolverInterfaceUnitTest
void OsiVolSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiVolSolverInterface class.
OsiVolSolverInterface::rc_
double * rc_
Pointer to dense vector of reduced costs.
Definition: OsiVolSolverInterface.hpp:842
OsiVolSolverInterface::rowpriceHotStart_
double * rowpriceHotStart_
An array to store the hotstart information between solveHotStart() calls.
Definition: OsiVolSolverInterface.hpp:852
OsiVolSolverInterface::getIntParam
bool getIntParam(OsiIntParam key, int &value) const
OsiVolSolverInterface::getMatrixByRow
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
OsiVolSolverInterface
Vol(ume) Solver Interface.
Definition: OsiVolSolverInterface.hpp:27
OsiVolSolverInterface::rhs_
double * rhs_
Pointer to dense vector of row right-hand side values.
Definition: OsiVolSolverInterface.hpp:822
OsiVolSolverInterface::isProvenOptimal
virtual bool isProvenOptimal() const
Is optimality proven?
OsiVolSolverInterface::objsense_
double objsense_
Sense of objective (1 for min; -1 for max)
Definition: OsiVolSolverInterface.hpp:832
OsiVolSolverInterface::operator=
OsiVolSolverInterface & operator=(const OsiVolSolverInterface &rhs)
Assignment operator.
OsiVolSolverInterface::colsol_
double * colsol_
Pointer to dense vector of primal structural variable values.
Definition: OsiVolSolverInterface.hpp:838
OsiVolSolverInterface::rowupper_
double * rowupper_
Pointer to dense vector of slack variable upper bounds.
Definition: OsiVolSolverInterface.hpp:816
OsiVolSolverInterface::isProvenPrimalInfeasible
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_::timesMajor
void timesMajor(const double *x, double *y) const
OsiVolSolverInterface::colRimResize_
void colRimResize_(const int newSize)
Reallocate the rim arrays corresponding to the columns.
OsiVolSolverInterface::rowMatrixCurrent_
bool rowMatrixCurrent_
A flag indicating whether the row ordered matrix is up-to-date.
Definition: OsiVolSolverInterface.hpp:786
OsiVolSolverInterface::addCols
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
OsiVolSolverInterface::getPrimalRays
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
OsiVolSolverInterface::isPrimalObjectiveLimitReached
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
OsiVolSolverInterface::getInfinity
virtual double getInfinity() const
Get solver's value for infinity.
Definition: OsiVolSolverInterface.hpp:257
OsiVolSolverInterface::setColSetBounds
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...