Vol 1.5.4
Loading...
Searching...
No Matches
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
17
18static 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
31private:
35
37 int * plusInd_;
40
42 int * minusInd_;
45
46 public:
49 void timesMajor(const double* x, double* y) const;
50 };
51
52public:
53 //---------------------------------------------------------------------------
56
57 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
103 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 //---------------------------------------------------------------------------
128
130 virtual CoinWarmStart* getWarmStart() const;
133 virtual bool setWarmStart(const CoinWarmStart* warmstart);
135
136 //---------------------------------------------------------------------------
143
144 virtual void markHotStart();
146 virtual void solveFromHotStart();
148 virtual void unmarkHotStart();
150
151 //---------------------------------------------------------------------------
166
167 virtual int getNumCols() const {
168 return rowMatrixCurrent_?
170
172 virtual int getNumRows() const {
173 return rowMatrixCurrent_?
175
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 OsiVolInfinity; }
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
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
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
574protected:
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);
582public:
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
683
684 //---------------------------------------------------------------------------
685
690
692 virtual OsiSolverInterface * clone(bool copyData = true) const;
693
696
699
703
704 //---------------------------------------------------------------------------
705
706protected:
708
709
710 virtual void applyRowCut(const OsiRowCut& rc);
711
713 virtual void applyColCut(const OsiColCut& cc);
715
716 //---------------------------------------------------------------------------
717
718private:
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 = DBL_MAX;
733 return 0;
734 }
736
737 //---------------------------------------------------------------------------
738
739private:
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
776
777 //---------------------------------------------------------------------------
778
779private:
780
781 //---------------------------------------------------------------------------
785
786 mutable bool rowMatrixCurrent_;
790 mutable bool colMatrixCurrent_;
794
795 //---------------------------------------------------------------------------
798
805
806 //---------------------------------------------------------------------------
809
810 double *colupper_;
812 double *collower_;
816 double *rowupper_;
818 double *rowlower_;
822 double *rhs_;
825 double *rowrange_;
827 double *objcoeffs_;
829
830 //---------------------------------------------------------------------------
832 double objsense_;
833
834 //---------------------------------------------------------------------------
837
838 double *colsol_;
840 double *rowprice_;
842 double *rc_;
844 double *lhs_;
848
849 //---------------------------------------------------------------------------
853
858
861};
862
863//#############################################################################
865void OsiVolSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
866
867#endif
std::vector< int > OsiVectorInt
OsiDblParam
OsiStrParam
OsiIntParam
void OsiVolSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiVolSolverInterface class.
static const double OsiVolInfinity
CoinBigIndex getNumElements() const
int getNumCols() const
int getNumRows() const
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)=0
void convertSenseToBound(const char sense, const double right, const double range, double &lower, double &upper) const
virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05) const
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)=0
virtual bool isFreeBinary(int colIndex) const
virtual bool isIntegerNonBinary(int colIndex) const
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
virtual bool isBinary(int colIndex) const
virtual double getObjValue() const=0
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
virtual int readMps(const char *filename, const char *extension="mps")
virtual bool isInteger(int colIndex) const
void convertBoundToSense(const double lower, const double upper, char &sense, double &right, double &range) const
OsiVolMatrixOneMinusOne_(const CoinPackedMatrix &m)
void timesMajor(const double *x, double *y) const
Vol(ume) Solver Interface.
virtual int getNumElements() const
Get number of nonzero elements.
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
virtual void unmarkHotStart()
Delete the snapshot.
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
void rowRimResize_(const int newSize)
Reallocate the rim arrays corresponding to the rows.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
virtual double getInfinity() const
Get solver's value for infinity.
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...
double * rc_
Pointer to dense vector of reduced costs.
double * lhs_
Pointer to dense vector of left hand sides (row activity levels)
bool test_zero_one_minusone_(const CoinPackedMatrix &m) const
test whether the given matrix is 0/1/-1 entries only.
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
int maxNumrows_
allocated size of the row related rim vectors
double * colsol_
Pointer to dense vector of primal structural variable values.
bool getIntParam(OsiIntParam key, int &value) const
double lagrangeanCost_
The Lagrangean cost, a lower bound on the objective value.
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows).
virtual void deleteRows(const int num, const int *rowIndices)
int maxNumcols_
allocated size of the column related rim vectors
double * rowprice_
Pointer to dense vector of dual row variable values.
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut (append to constraint matrix).
double * rowpriceHotStart_
An array to store the hotstart information between solveHotStart() calls.
bool rowMatrixCurrent_
A flag indicating whether the row ordered matrix is up-to-date.
void checkData_() const
Test whether the Volume Algorithm can be applied to the given problem.
virtual void writeMps(const char *filename, const char *extension="mps", double objSense=0.0) const
Write the problem into an mps file of the given filename.
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
friend void OsiVolSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiVolSolverInterface class.
void convertSensesToBounds_()
For each row convert sense/rhs style row constraints to LB/UB style.
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
bool setIntParam(OsiIntParam key, int value)
void rowRimAllocator_()
A method allocating sufficient space for the rim vectors corresponding to the rows.
virtual ~OsiVolSolverInterface()
Destructor.
bool setDblParam(OsiDblParam key, double value)
virtual void markHotStart()
Create a hotstart point of the optimization process.
double objsense_
Sense of objective (1 for min; -1 for max)
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 ...
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 setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously The default implementation just invokes setRowLowe...
virtual void addRow(const CoinPackedVectorBase &vec, const char rowsen, const double rowrhs, const double rowrng)
virtual void deleteCols(const int num, const int *colIndices)
virtual void resolve()
Resolve an LP relaxation after problem modification.
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
virtual void branchAndBound()
Invoke solver's built-in enumeration algorithm.
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
virtual void initialSolve()
Solve initial LP relaxation.
virtual int compute_rc(const VOL_dvector &u, VOL_dvector &rc)
compute reduced costs
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const char *rowsen, const double *rowrhs, const double *rowrng)
void colRimResize_(const int newSize)
Reallocate the rim arrays corresponding to the columns.
virtual void setInteger(const int *indices, int len)
Set the variables listed in indices (which is of length len) to be integer variables.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever "iteration" mean to the solver.
bool setStrParam(OsiStrParam key, const std::string &value)
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
virtual bool isAbandoned() const
Are there a numerical difficulties?
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
char * rowsense_
Pointer to dense vector of row sense indicators.
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
bool getStrParam(OsiStrParam key, std::string &value) const
virtual double getObjValue() const
Get objective function value.
double * rowlower_
Pointer to dense vector of slack variable lower bounds.
bool getDblParam(OsiDblParam key, double &value) const
void convertBoundsToSenses_()
For each row convert LB/UB style row constraints to sense/rhs style.
virtual bool isIterationLimitReached() const
Iteration limit reached?
void initFromRhsSenseRange(const int rownum, const char *rowsen, const double *rowrhs, const double *rowrng)
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
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.
void colRimAllocator_()
A method allocating sufficient space for the rim vectors corresponding to the columns.
double * rhs_
Pointer to dense vector of row right-hand side values.
bool isZeroOneMinusOne_
An indicator whether the matrix is 0/1/-1.
virtual int getNumRows() const
Get number of rows.
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
OsiVolMatrixOneMinusOne_ * rowMatrixOneMinusOne_
The row ordered matrix without the elements.
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...
CoinPackedMatrix colMatrix_
The problem matrix in a column ordered form.
OsiVolSolverInterface & operator=(const OsiVolSolverInterface &rhs)
Assignment operator.
virtual CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
void initFromClbCubObj(const int colnum, const double *collb, const double *colub, const double *obj)
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
void gutsOfDestructor_()
A method deleting every member data.
double * objcoeffs_
Pointer to dense vector of objective coefficients.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
VOL_problem volprob_
The volume solver.
CoinPackedMatrix rowMatrix_
The problem matrix in a row ordered form.
void updateColMatrix_() const
Update the column ordered matrix from the row ordered one.
OsiVolSolverInterface(const OsiVolSolverInterface &)
Copy constructor.
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
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 bool isProvenOptimal() const
Is optimality proven?
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (adjust one or more bounds).
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
OsiVolSolverInterface()
Default Constructor.
void updateRowMatrix_() const
Update the row ordered matrix from the column ordered one.
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
double * rowupper_
Pointer to dense vector of slack variable upper bounds.
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...
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
VOL_problem * volprob()
Get pointer to Vol model.
void compute_rc_(const double *u, double *rc) const
Compute the reduced costs (rc) with respect to the dual values given in u.
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
bool colMatrixCurrent_
A flag indicating whether the column ordered matrix is up-to-date.
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
void initFromRlbRub(const int rownum, const double *rowlb, const double *rowub)
virtual void loadProblem(const CoinPackedMatrix &matrix, const double *collb, const double *colub, const double *obj, const char *rowsen, const double *rowrhs, const double *rowrng)
Load in an problem by copying the arguments (the constraints on the rows are given by sense/rhs/range...
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
bool * continuous_
Pointer to dense vector of bool to indicate if column is continuous.
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
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 const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
virtual void setContinuous(const int *indices, int len)
Set the variables listed in indices (which is of length len) to be continuous variables.
double * colupper_
Pointer to dense vector of structural variable upper bounds.
virtual int getNumCols() const
Get number of columns.
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.
OsiVolMatrixOneMinusOne_ * colMatrixOneMinusOne_
The column ordered matrix without the elements.
double * collower_
Pointer to dense vector of structural variable lower bounds.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
int iter() const