|
Loading...
Searching...
No Matches
#include <soplex.h>
|
|
| SoPlexBase () |
| default constructor
|
|
SoPlexBase< R > & | operator= (const SoPlexBase< R > &rhs) |
| assignment operator
|
|
| SoPlexBase (const SoPlexBase< R > &rhs) |
| copy constructor
|
|
virtual | ~SoPlexBase () |
| destructor
|
|
|
int | numRows () const |
| returns number of rows
|
|
int | numRowsReal () const |
|
int | numRowsRational () const |
|
int | numCols () const |
| Templated function that returns number of columns.
|
|
int | numColsReal () const |
|
int | numColsRational () const |
|
int | numNonzeros () const |
| returns number of nonzeros
|
|
int | numNonzerosRational () const |
|
R | minAbsNonzeroReal () const |
| returns smallest non-zero element in absolute value
|
|
R | maxAbsNonzeroReal () const |
| returns biggest non-zero element in absolute value
|
|
R | coefReal (int row, int col) const |
| returns (unscaled) coefficient
|
|
const SVectorBase< R > & | rowVectorRealInternal (int i) const |
| returns vector of row i , ignoring scaling
|
|
void | getRowVectorReal (int i, DSVectorBase< R > &row) const |
| gets vector of row i
|
|
const VectorBase< R > & | rhsRealInternal () const |
| returns right-hand side vector, ignoring scaling
|
|
void | getRhsReal (VectorBase< R > &rhs) const |
| gets right-hand side vector
|
|
R | rhsReal (int i) const |
| returns right-hand side of row i
|
|
const VectorBase< R > & | lhsRealInternal () const |
| returns left-hand side vector, ignoring scaling
|
|
void | getLhsReal (VectorBase< R > &lhs) const |
| gets left-hand side vector
|
|
R | lhsReal (int i) const |
| returns left-hand side of row i
|
|
LPRowBase< R >::Type | rowTypeReal (int i) const |
| returns inequality type of row i
|
|
const SVectorBase< R > & | colVectorRealInternal (int i) const |
| returns vector of col i , ignoring scaling
|
|
void | getColVectorReal (int i, DSVectorBase< R > &col) const |
| gets vector of col i
|
|
const VectorBase< R > & | upperRealInternal () const |
| returns upper bound vector
|
|
R | upperReal (int i) const |
| returns upper bound of column i
|
|
void | getUpperReal (VectorBase< R > &upper) const |
| gets upper bound vector
|
|
const VectorBase< R > & | lowerRealInternal () const |
| returns lower bound vector
|
|
R | lowerReal (int i) const |
| returns lower bound of column i
|
|
void | getLowerReal (VectorBase< R > &lower) const |
| gets lower bound vector
|
|
void | getObjReal (VectorBase< R > &obj) const |
| gets objective function vector
|
|
R | objReal (int i) const |
| returns objective value of column i
|
|
const VectorBase< R > & | maxObjRealInternal () const |
| returns objective function vector after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
|
|
R | maxObjReal (int i) const |
| returns objective value of column i after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
|
|
void | getNdualNorms (int &nnormsRow, int &nnormsCol) const |
| gets number of available dual norms
|
|
bool | getDualNorms (int &nnormsRow, int &nnormsCol, R *norms) const |
| gets steepest edge norms and returns false if they are not available
|
|
bool | setDualNorms (int nnormsRow, int nnormsCol, R *norms) |
| sets steepest edge norms and returns false if that's not possible
|
|
void | setIntegralityInformation (int ncols, int *intInfo) |
| pass integrality information about the variables to the solver
|
|
|
Rational | minAbsNonzeroRational () const |
| returns smallest non-zero element in absolute value
|
|
Rational | maxAbsNonzeroRational () const |
| returns biggest non-zero element in absolute value
|
|
void | getRowRational (int i, LPRowRational &lprow) const |
| gets row i
|
|
void | getRowsRational (int start, int end, LPRowSetRational &lprowset) const |
| gets rows start , ..., end .
|
|
const SVectorRational & | rowVectorRational (int i) const |
| returns vector of row i
|
|
const VectorRational & | rhsRational () const |
| returns right-hand side vector
|
|
const Rational & | rhsRational (int i) const |
| returns right-hand side of row i
|
|
const VectorRational & | lhsRational () const |
| returns left-hand side vector
|
|
const Rational & | lhsRational (int i) const |
| returns left-hand side of row i
|
|
LPRowRational::Type | rowTypeRational (int i) const |
| returns inequality type of row i
|
|
void | getColRational (int i, LPColRational &lpcol) const |
| gets column i
|
|
void | getColsRational (int start, int end, LPColSetRational &lpcolset) const |
| gets columns start , ..., end
|
|
const SVectorRational & | colVectorRational (int i) const |
| returns vector of column i
|
|
const VectorRational & | upperRational () const |
| returns upper bound vector
|
|
const Rational & | upperRational (int i) const |
| returns upper bound of column i
|
|
const VectorRational & | lowerRational () const |
| returns lower bound vector
|
|
const Rational & | lowerRational (int i) const |
| returns lower bound of column i
|
|
void | getObjRational (VectorRational &obj) const |
| gets objective function vector
|
|
void | getObjRational (int i, Rational &obj) const |
| gets objective value of column i
|
|
Rational | objRational (int i) const |
| returns objective value of column i
|
|
const VectorRational & | maxObjRational () const |
| returns objective function vector after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
|
|
const Rational & | maxObjRational (int i) const |
| returns objective value of column i after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
|
|
|
void | addRowReal (const LPRowBase< R > &lprow) |
| adds a single row
|
|
void | addRowsReal (const LPRowSetBase< R > &lprowset) |
| adds multiple rows
|
|
void | addColReal (const LPColBase< R > &lpcol) |
| adds a single column
|
|
void | addColsReal (const LPColSetBase< R > &lpcolset) |
| adds multiple columns
|
|
void | changeRowReal (int i, const LPRowBase< R > &lprow) |
| replaces row i with lprow
|
|
void | changeLhsReal (const VectorBase< R > &lhs) |
| changes left-hand side vector for constraints to lhs
|
|
void | changeLhsReal (int i, const R &lhs) |
| changes left-hand side of row i to lhs
|
|
void | changeRhsReal (const VectorBase< R > &rhs) |
| changes right-hand side vector to rhs
|
|
void | changeRhsReal (int i, const R &rhs) |
| changes right-hand side of row i to rhs
|
|
void | changeRangeReal (const VectorBase< R > &lhs, const VectorBase< R > &rhs) |
| changes left- and right-hand side vectors
|
|
void | changeRangeReal (int i, const R &lhs, const R &rhs) |
| changes left- and right-hand side of row i
|
|
void | changeColReal (int i, const LPColReal &lpcol) |
| replaces column i with lpcol
|
|
void | changeLowerReal (const VectorBase< R > &lower) |
| changes vector of lower bounds to lower
|
|
void | changeLowerReal (int i, const R &lower) |
| changes lower bound of column i to lower
|
|
void | changeUpperReal (const VectorBase< R > &upper) |
| changes vector of upper bounds to upper
|
|
void | changeUpperReal (int i, const R &upper) |
| changes i 'th upper bound to upper
|
|
void | changeBoundsReal (const VectorBase< R > &lower, const VectorBase< R > &upper) |
| changes vectors of column bounds to lower and upper
|
|
void | changeBoundsReal (int i, const R &lower, const R &upper) |
| changes bounds of column i to lower and upper
|
|
void | changeObjReal (const VectorBase< R > &obj) |
| changes objective function vector to obj
|
|
void | changeObjReal (int i, const R &obj) |
| changes objective coefficient of column i to obj
|
|
void | changeElementReal (int i, int j, const R &val) |
| changes matrix entry in row i and column j to val
|
|
void | removeRowReal (int i) |
| removes row i
|
|
void | removeRowsReal (int perm[]) |
| removes all rows with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where row i has been moved to; note that perm must point to an array of size at least numRows()
|
|
void | removeRowsReal (int idx[], int n, int perm[]=0) |
| remove all rows with indices in array idx of size n ; an array perm of size numRows() may be passed as buffer memory
|
|
void | removeRowRangeReal (int start, int end, int perm[]=0) |
| removes rows start to end including both; an array perm of size numRows() may be passed as buffer memory
|
|
void | removeColReal (int i) |
| removes column i
|
|
void | removeColsReal (int perm[]) |
| removes all columns with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where column i has been moved to; note that perm must point to an array of size at least numColsReal()
|
|
void | removeColsReal (int idx[], int n, int perm[]=0) |
| remove all columns with indices in array idx of size n ; an array perm of size numColsReal() may be passed as buffer memory
|
|
void | removeColRangeReal (int start, int end, int perm[]=0) |
| removes columns start to end including both; an array perm of size numColsReal() may be passed as buffer memory
|
|
void | clearLPReal () |
| clears the LP
|
|
void | syncLPReal () |
| synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, if sync mode is manual
|
|
|
void | addRowRational (const LPRowRational &lprow) |
| adds a single row
|
|
void | addRowRational (const mpq_t *lhs, const mpq_t *rowValues, const int *rowIndices, const int rowSize, const mpq_t *rhs) |
| adds a single row (GMP only method)
|
|
void | addRowsRational (const mpq_t *lhs, const mpq_t *rowValues, const int *rowIndices, const int *rowStarts, const int *rowLengths, const int numRows, const int numValues, const mpq_t *rhs) |
| adds a set of rows (GMP only method)
|
|
void | addRowsRational (const LPRowSetRational &lprowset) |
| adds multiple rows
|
|
void | addColRational (const LPColRational &lpcol) |
| adds a single column
|
|
void | addColRational (const mpq_t *obj, const mpq_t *lower, const mpq_t *colValues, const int *colIndices, const int colSize, const mpq_t *upper) |
| adds a single column (GMP only method)
|
|
void | addColsRational (const mpq_t *obj, const mpq_t *lower, const mpq_t *colValues, const int *colIndices, const int *colStarts, const int *colLengths, const int numCols, const int numValues, const mpq_t *upper) |
| adds a set of columns (GMP only method)
|
|
void | addColsRational (const LPColSetRational &lpcolset) |
| adds multiple columns
|
|
void | changeRowRational (int i, const LPRowRational &lprow) |
| replaces row i with lprow
|
|
void | changeLhsRational (const VectorRational &lhs) |
| changes left-hand side vector for constraints to lhs
|
|
void | changeLhsRational (int i, const Rational &lhs) |
| changes left-hand side of row i to lhs
|
|
void | changeLhsRational (int i, const mpq_t *lhs) |
| changes left-hand side of row i to lhs (GMP only method)
|
|
void | changeRhsRational (const VectorRational &rhs) |
| changes right-hand side vector to rhs
|
|
void | changeRhsRational (const mpq_t *rhs, int rhsSize) |
| changes right-hand side vector to rhs (GMP only method)
|
|
void | changeRhsRational (int i, const Rational &rhs) |
| changes right-hand side of row i to rhs
|
|
void | changeRangeRational (const VectorRational &lhs, const VectorRational &rhs) |
| changes left- and right-hand side vectors
|
|
void | changeRangeRational (int i, const Rational &lhs, const Rational &rhs) |
| changes left- and right-hand side of row i
|
|
void | changeRangeRational (int i, const mpq_t *lhs, const mpq_t *rhs) |
| changes left- and right-hand side of row i (GMP only method)
|
|
void | changeColRational (int i, const LPColRational &lpcol) |
| replaces column i with lpcol
|
|
void | changeLowerRational (const VectorRational &lower) |
| changes vector of lower bounds to lower
|
|
void | changeLowerRational (int i, const Rational &lower) |
| changes lower bound of column i to lower
|
|
void | changeLowerRational (int i, const mpq_t *lower) |
| changes lower bound of column i to lower (GMP only method)
|
|
void | changeUpperRational (const VectorRational &upper) |
| changes vector of upper bounds to upper
|
|
void | changeUpperRational (int i, const Rational &upper) |
| changes i 'th upper bound to upper
|
|
void | changeUpperRational (int i, const mpq_t *upper) |
| changes upper bound of column i to upper (GMP only method)
|
|
void | changeBoundsRational (const VectorRational &lower, const VectorRational &upper) |
| changes vectors of column bounds to lower and upper
|
|
void | changeBoundsRational (int i, const Rational &lower, const Rational &upper) |
| changes bounds of column i to lower and upper
|
|
void | changeBoundsRational (int i, const mpq_t *lower, const mpq_t *upper) |
| changes bounds of column i to lower and upper (GMP only method)
|
|
void | changeObjRational (const VectorRational &obj) |
| changes objective function vector to obj
|
|
void | changeObjRational (int i, const Rational &obj) |
| changes objective coefficient of column i to obj
|
|
void | changeObjRational (int i, const mpq_t *obj) |
| changes objective coefficient of column i to obj (GMP only method)
|
|
void | changeElementRational (int i, int j, const Rational &val) |
| changes matrix entry in row i and column j to val
|
|
void | changeElementRational (int i, int j, const mpq_t *val) |
| changes matrix entry in row i and column j to val (GMP only method)
|
|
void | removeRowRational (int i) |
| removes row i
|
|
void | removeRowsRational (int perm[]) |
| removes all rows with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where row i has been moved to; note that perm must point to an array of size at least numRowsRational()
|
|
void | removeRowsRational (int idx[], int n, int perm[]=0) |
| remove all rows with indices in array idx of size n ; an array perm of size numRowsRational() may be passed as buffer memory
|
|
void | removeRowRangeRational (int start, int end, int perm[]=0) |
| removes rows start to end including both; an array perm of size numRowsRational() may be passed as buffer memory
|
|
void | removeColRational (int i) |
| removes column i
|
|
void | removeColsRational (int perm[]) |
| removes all columns with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where column i has been moved to; note that perm must point to an array of size at least numColsRational()
|
|
void | removeColsRational (int idx[], int n, int perm[]=0) |
| remove all columns with indices in array idx of size n ; an array perm of size numColsRational() may be passed as buffer memory
|
|
void | removeColRangeRational (int start, int end, int perm[]=0) |
| removes columns start to end including both; an array perm of size numColsRational() may be passed as buffer memory
|
|
void | clearLPRational () |
| clears the LP
|
|
void | syncLPRational () |
| synchronizes rational LP with real LP, i.e., copies real LP to rational LP, if sync mode is manual
|
|
|
SPxSolverBase< R >::Status | optimize (volatile bool *interrupt=NULL) |
| optimize the given LP
|
|
SPxSolverBase< R >::Status | solve (volatile bool *interrupt=NULL) |
|
SPxSolverBase< R >::Status | status () const |
| returns the current solver status
|
|
bool | isPrimalFeasible () const |
| is stored primal solution feasible?
|
|
bool | hasSol () const |
| is a solution available (not neccessarily feasible)?
|
|
bool | hasPrimal () const |
| deprecated: use hasSol() instead
|
|
bool | hasDual () const |
| deprecated: use hasSol() instead
|
|
bool | hasPrimalRay () const |
| is a primal unbounded ray available?
|
|
bool | isDualFeasible () const |
| is stored dual solution feasible?
|
|
bool | hasDualFarkas () const |
| is Farkas proof of infeasibility available?
|
|
bool | ignoreUnscaledViolations () |
| sets the status to OPTIMAL in case the LP has been solved with unscaled violations
|
|
|
R | objValueReal () |
| returns the objective value if a primal solution is available
|
|
bool | getPrimal (VectorBase< R > &vector) |
| gets the primal solution vector if available; returns true on success
|
|
bool | getPrimalReal (R *p_vector, int size) |
|
bool | getPrimalRational (VectorRational &vector) |
|
bool | getSlacksReal (VectorBase< R > &vector) |
| gets the vector of slack values if available; returns true on success
|
|
bool | getSlacksReal (R *p_vector, int dim) |
|
bool | getPrimalRay (VectorBase< R > &vector) |
| gets the primal ray if available; returns true on success
|
|
bool | getPrimalRayReal (R *vector, int dim) |
|
bool | getPrimalRayRational (VectorRational &vector) |
|
bool | getDual (VectorBase< R > &vector) |
| gets the dual solution vector if available; returns true on success
|
|
bool | getDualReal (R *p_vector, int dim) |
|
bool | getDualRational (VectorRational &vector) |
|
bool | getRedCost (VectorBase< R > &vector) |
| gets the vector of reduced cost values if available; returns true on success
|
|
bool | getRedCostReal (R *vector, int dim) |
|
bool | getRedCostRational (VectorRational &vector) |
|
bool | getDualFarkas (VectorBase< R > &vector) |
| gets the Farkas proof if available; returns true on success
|
|
bool | getDualFarkasReal (R *vector, int dim) |
|
bool | getDualFarkasRational (VectorRational &vector) |
|
bool | getBoundViolation (R &maxviol, R &sumviol) |
| gets violation of bounds; returns true on success
|
|
bool | getBoundViolationRational (Rational &maxviol, Rational &sumviol) |
|
bool | getRowViolation (R &maxviol, R &sumviol) |
| gets violation of constraints; returns true on success
|
|
bool | getRowViolationRational (Rational &maxviol, Rational &sumviol) |
|
bool | getRedCostViolation (R &maxviol, R &sumviol) |
| gets violation of reduced costs; returns true on success
|
|
bool | getRedCostViolationRational (Rational &maxviol, Rational &sumviol) |
|
bool | getDualViolation (R &maxviol, R &sumviol) |
| gets violation of dual multipliers; returns true on success
|
|
bool | getDualViolationRational (Rational &maxviol, Rational &sumviol) |
|
|
Rational | objValueRational () |
| returns the objective value if a primal solution is available
|
|
bool | getSlacksRational (VectorRational &vector) |
| gets the vector of slack values if available; returns true on success
|
|
bool | getPrimalRational (mpq_t *vector, const int size) |
| gets the primal solution vector if available; returns true on success (GMP only method)
|
|
bool | getSlacksRational (mpq_t *vector, const int size) |
| gets the vector of slack values if available; returns true on success (GMP only method)
|
|
bool | getPrimalRayRational (mpq_t *vector, const int size) |
| gets the primal ray if LP is unbounded; returns true on success (GMP only method)
|
|
bool | getDualRational (mpq_t *vector, const int size) |
| gets the dual solution vector if available; returns true on success (GMP only method)
|
|
bool | getRedCostRational (mpq_t *vector, const int size) |
| gets the vector of reduced cost values if available; returns true on success (GMP only method)
|
|
bool | getDualFarkasRational (mpq_t *vector, const int size) |
| gets the Farkas proof if LP is infeasible; returns true on success (GMP only method)
|
|
int | totalSizePrimalRational (const int base=2) |
| get size of primal solution
|
|
int | totalSizeDualRational (const int base=2) |
| get size of dual solution
|
|
int | dlcmSizePrimalRational (const int base=2) |
| get size of least common multiple of denominators in primal solution
|
|
int | dlcmSizeDualRational (const int base=2) |
| get size of least common multiple of denominators in dual solution
|
|
int | dmaxSizePrimalRational (const int base=2) |
| get size of largest denominator in primal solution
|
|
int | dmaxSizeDualRational (const int base=2) |
| get size of largest denominator in dual solution
|
|
|
bool | hasBasis () const |
| is an advanced starting basis available?
|
|
SPxBasisBase< R >::SPxStatus | basisStatus () const |
| returns the current basis status
|
|
SPxSolverBase< R >::VarStatus | basisRowStatus (int row) const |
| returns basis status for a single row
|
|
SPxSolverBase< R >::VarStatus | basisColStatus (int col) const |
| returns basis status for a single column
|
|
void | getBasis (typename SPxSolverBase< R >::VarStatus rows[], typename SPxSolverBase< R >::VarStatus cols[]) const |
| gets current basis via arrays of statuses
|
|
void | getBasisInd (int *bind) const |
| gets the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m
|
|
bool | getBasisMetric (R &metric, int type=0) |
|
bool | getEstimatedCondition (R &condition) |
| computes an estimated condition number for the current basis matrix using the power method; returns true on success
|
|
bool | getExactCondition (R &condition) |
| computes the exact condition number for the current basis matrix using the power method; returns true on success
|
|
bool | getBasisInverseRowReal (int r, R *coef, int *inds=NULL, int *ninds=NULL, bool unscale=true) |
| computes row r of basis inverse; returns true on success
|
|
bool | getBasisInverseColReal (int c, R *coef, int *inds=NULL, int *ninds=NULL, bool unscale=true) |
| computes column c of basis inverse; returns true on success
|
|
bool | getBasisInverseTimesVecReal (R *rhs, R *sol, bool unscale=true) |
| computes dense solution of basis matrix B * sol = rhs ; returns true on success
|
|
bool | multBasis (R *vec, bool unscale=true) |
| multiply with basis matrix; B * vec (inplace)
|
|
bool | multBasisTranspose (R *vec, bool unscale=true) |
| multiply with transpose of basis matrix; vec * B^T (inplace)
|
|
bool | computeBasisInverseRational () |
| compute rational basis inverse; returns true on success
|
|
bool | getBasisIndRational (DataArray< int > &bind) |
| gets an array of indices for the columns of the rational basis matrix; bind[i] >= 0 means that the i-th column of the basis matrix contains variable bind[i]; bind[i] < 0 means that the i-th column of the basis matrix contains the slack variable for row -bind[i]-1; performs rational factorization if not available; returns true on success
|
|
bool | getBasisInverseRowRational (const int r, SSVectorRational &vec) |
| computes row r of basis inverse; performs rational factorization if not available; returns true on success
|
|
bool | getBasisInverseColRational (const int c, SSVectorRational &vec) |
| computes column c of basis inverse; performs rational factorization if not available; returns true on success
|
|
bool | getBasisInverseTimesVecRational (const SVectorRational &rhs, SSVectorRational &sol) |
| computes solution of basis matrix B * sol = rhs; performs rational factorization if not available; returns true on success
|
|
void | setBasis (const typename SPxSolverBase< R >::VarStatus rows[], const typename SPxSolverBase< R >::VarStatus cols[]) |
| sets starting basis via arrays of statuses
|
|
void | clearBasis () |
| clears starting basis
|
|
|
int | numIterations () const |
| number of iterations since last call to solve
|
|
Real | solveTime () const |
| time spent in last call to solve
|
|
std::string | statisticString () const |
| statistical information in form of a string
|
|
const char * | getStarterName () |
| name of starter
|
|
const char * | getSimplifierName () |
| name of simplifier
|
|
const char * | getScalerName () |
| name of scaling method
|
|
const char * | getPricerName () |
| name of currently loaded pricer
|
|
const char * | getRatiotesterName () |
| name of currently loaded ratiotester
|
|
|
bool | readFile (const char *filename, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) |
| reads LP file in LP or MPS format according to READMODE parameter; gets row names, column names, and integer variables if desired; returns true on success
|
|
bool | writeFile (const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *intvars=0, const bool unscale=true) const |
| Templated write function Real writes real LP to file; LP or MPS format is chosen from the extension in filename ; if rowNames and colNames are NULL , default names are used; if intVars is not NULL , the variables contained in it are marked as integer; returns true on success Rational writes rational LP to file; LP or MPS format is chosen from the extension in filename ; if rowNames and colNames are NULL , default names are used; if intVars is not NULL , the variables contained in it are marked as integer; returns true on success.
|
|
bool | writeFileRational (const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *intvars=0) const |
|
bool | writeFileReal (const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *intvars=0, const bool unscale=true) const |
|
bool | writeDualFileReal (const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *intvars=0) const |
| writes the dual of the real LP to file; LP or MPS format is chosen from the extension in filename ; if rowNames and colNames are NULL , default names are used; if intVars is not NULL , the variables contained in it are marked as integer; returns true on success
|
|
bool | readBasisFile (const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0) |
| reads basis information from filename and returns true on success; if rowNames and colNames are NULL , default names are assumed; returns true on success
|
|
bool | writeBasisFile (const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const bool cpxFormat=false) const |
| writes basis information to filename ; if rowNames and colNames are NULL , default names are used; returns true on success
|
|
void | writeStateReal (const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const bool cpxFormat=false) const |
| writes internal LP, basis information, and parameter settings; if rowNames and colNames are NULL , default names are used
|
|
void | writeStateRational (const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const bool cpxFormat=false) const |
| writes internal LP, basis information, and parameter settings; if rowNames and colNames are NULL , default names are used
|
|
|
void | setTimings (const Timer::TYPE ttype) |
| set statistic timers to a certain type
|
|
void | printSolutionStatistics (std::ostream &os) |
| prints solution statistics
|
|
void | printSolvingStatistics (std::ostream &os) |
| prints statistics on solving process
|
|
void | printShortStatistics (std::ostream &os) |
| prints short statistics
|
|
void | printStatistics (std::ostream &os) |
| prints complete statistics
|
|
void | printStatus (std::ostream &os, typename SPxSolverBase< R >::Status status) |
| prints status
|
|
|
|
void | _ensureDSVectorRationalMemory (DSVectorRational &vec, const int newmax) const |
| extends sparse vector to hold newmax entries if and only if it holds no more free entries
|
|
void | _idxToPerm (int *idx, int idxSize, int *perm, int permSize) const |
| creates a permutation for removing rows/columns from an array of indices
|
|
void | _rangeToPerm (int start, int end, int *perm, int permSize) const |
| creates a permutation for removing rows/columns from a range of indices
|
|
bool | _isConsistent () const |
| checks consistency
|
|
bool | _isSolveStopped (bool &stoppedTime, bool &stoppedIter) const |
| should solving process be stopped?
|
|
RangeType | _rangeTypeReal (const R &lower, const R &upper) const |
| determines RangeType from real bounds
|
|
RangeType | _rangeTypeRational (const Rational &lower, const Rational &upper) const |
| determines RangeType from rational bounds
|
|
RangeType | _switchRangeType (const RangeType &rangeType) const |
| switches RANGETYPE_LOWER to RANGETYPE_UPPER and vice versa
|
|
bool | _lowerFinite (const RangeType &rangeType) const |
| checks whether RangeType corresponds to finite lower bound
|
|
bool | _upperFinite (const RangeType &rangeType) const |
| checks whether RangeType corresponds to finite upper bound
|
|
|
void | _addRowReal (const LPRowBase< R > &lprow) |
| adds a single row to the real LP and adjusts basis
|
|
void | _addRowReal (R lhs, const SVectorBase< R > &lprow, R rhs) |
| adds a single row to the real LP and adjusts basis
|
|
void | _addRowsReal (const LPRowSetBase< R > &lprowset) |
| adds multiple rows to the real LP and adjusts basis
|
|
void | _addColReal (const LPColReal &lpcol) |
| adds a single column to the real LP and adjusts basis
|
|
void | _addColReal (R obj, R lower, const SVectorBase< R > &lpcol, R upper) |
| adds a single column to the real LP and adjusts basis
|
|
void | _addColsReal (const LPColSetReal &lpcolset) |
| adds multiple columns to the real LP and adjusts basis
|
|
void | _changeRowReal (int i, const LPRowBase< R > &lprow) |
| replaces row i with lprow and adjusts basis
|
|
void | _changeLhsReal (const VectorBase< R > &lhs) |
| changes left-hand side vector for constraints to lhs and adjusts basis
|
|
void | _changeLhsReal (int i, const R &lhs) |
| changes left-hand side of row i to lhs and adjusts basis
|
|
void | _changeRhsReal (const VectorBase< R > &rhs) |
| changes right-hand side vector to rhs and adjusts basis
|
|
void | _changeRhsReal (int i, const R &rhs) |
| changes right-hand side of row i to rhs and adjusts basis
|
|
void | _changeRangeReal (const VectorBase< R > &lhs, const VectorBase< R > &rhs) |
| changes left- and right-hand side vectors and adjusts basis
|
|
void | _changeRangeReal (int i, const R &lhs, const R &rhs) |
| changes left- and right-hand side of row i and adjusts basis
|
|
void | _changeColReal (int i, const LPColReal &lpcol) |
| replaces column i with lpcol and adjusts basis
|
|
void | _changeLowerReal (const VectorBase< R > &lower) |
| changes vector of lower bounds to lower and adjusts basis
|
|
void | _changeLowerReal (int i, const R &lower) |
| changes lower bound of column i to lower and adjusts basis
|
|
void | _changeUpperReal (const VectorBase< R > &upper) |
| changes vector of upper bounds to upper and adjusts basis
|
|
void | _changeUpperReal (int i, const R &upper) |
| changes i 'th upper bound to upper and adjusts basis
|
|
void | _changeBoundsReal (const VectorBase< R > &lower, const VectorBase< R > &upper) |
| changes vectors of column bounds to lower and upper and adjusts basis
|
|
void | _changeBoundsReal (int i, const R &lower, const R &upper) |
| changes bounds of column i to lower and upper and adjusts basis
|
|
void | _changeElementReal (int i, int j, const R &val) |
| changes matrix entry in row i and column j to val and adjusts basis
|
|
void | _removeRowReal (int i) |
| removes row i and adjusts basis
|
|
void | _removeRowsReal (int perm[]) |
| removes all rows with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where row i has been moved to; note that perm must point to an array of size at least numRows()
|
|
void | _removeRowsReal (int idx[], int n, int perm[]) |
| remove all rows with indices in array idx of size n ; an array perm of size numRows() may be passed as buffer memory
|
|
void | _removeRowRangeReal (int start, int end, int perm[]) |
| removes rows start to end including both; an array perm of size numRows() may be passed as buffer memory
|
|
void | _removeColReal (int i) |
| removes column i
|
|
void | _removeColsReal (int perm[]) |
| removes all columns with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where column i has been moved to; note that perm must point to an array of size at least numColsReal()
|
|
void | _removeColsReal (int idx[], int n, int perm[]) |
| remove all columns with indices in array idx of size n ; an array perm of size numColsReal() may be passed as buffer memory
|
|
void | _removeColRangeReal (int start, int end, int perm[]) |
| removes columns start to end including both; an array perm of size numColsReal() may be passed as buffer memory
|
|
void | _invalidateSolution () |
| invalidates solution
|
|
void | _enableSimplifierAndScaler () |
| enables simplifier and scaler according to current parameters
|
|
void | _disableSimplifierAndScaler () |
| disables simplifier and scaler
|
|
void | _ensureRationalLP () |
| ensures that the rational LP is available; performs no sync
|
|
void | _ensureRealLPLoaded () |
| ensures that the real LP and the basis are loaded in the solver; performs no sync
|
|
void | _solveRealLPAndRecordStatistics (volatile bool *interrupt=NULL) |
| call floating-point solver and update statistics on iterations etc.
|
|
bool | _readFileReal (const char *filename, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) |
| reads real LP in LP or MPS format from file and returns true on success; gets row names, column names, and integer variables if desired
|
|
bool | _readFileRational (const char *filename, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) |
| reads rational LP in LP or MPS format from file and returns true on success; gets row names, column names, and integer variables if desired
|
|
void | _completeRangeTypesRational () |
| completes range type arrays after adding columns and/or rows
|
|
void | _recomputeRangeTypesReal () |
| recomputes range types from scratch using real LP
|
|
void | _recomputeRangeTypesRational () |
| recomputes range types from scratch using rational LP
|
|
void | _syncLPReal (bool time=true) |
| synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, without looking at the sync mode
|
|
void | _syncLPRational (bool time=true) |
| synchronizes rational LP with real LP, i.e., copies real LP to rational LP, without looking at the sync mode
|
|
void | _syncRealSolution () |
| synchronizes rational solution with real solution, i.e., copies (rounded) rational solution to real solution
|
|
void | _syncRationalSolution () |
| synchronizes real solution with rational solution, i.e., copies real solution to rational solution
|
|
const UnitVectorRational * | _unitVectorRational (const int i) |
| returns pointer to a constant unit vector available until destruction of the SoPlexBase class
|
|
bool | _parseSettingsLine (char *line, const int lineNumber) |
| parses one line in a settings file and returns true on success; note that the string is modified
|
|
|
void | _performOptIRStable (SolRational &sol, bool acceptUnbounded, bool acceptInfeasible, int minRounds, bool &primalFeasible, bool &dualFeasible, bool &infeasible, bool &unbounded, bool &stoppedTime, bool &stoppedIter, bool &error) |
| solves current problem with iterative refinement and recovery mechanism
|
|
void | _performUnboundedIRStable (SolRational &sol, bool &hasUnboundedRay, bool &stoppedTime, bool &stoppedIter, bool &error) |
| performs iterative refinement on the auxiliary problem for testing unboundedness
|
|
void | _performFeasIRStable (SolRational &sol, bool &withDualFarkas, bool &stoppedTime, bool &stoppedIter, bool &error) |
| performs iterative refinement on the auxiliary problem for testing feasibility
|
|
void | _lift () |
| reduces matrix coefficient in absolute value by the lifting procedure of Thiele et al. 2013
|
|
void | _project (SolRational &sol) |
| undoes lifting
|
|
void | _storeBasis () |
| store basis
|
|
void | _restoreBasis () |
| restore basis
|
|
void | _storeLPReal () |
| stores objective, bounds, and sides of real LP
|
|
void | _restoreLPReal () |
| restores objective, bounds, and sides of real LP
|
|
void | _transformEquality () |
| introduces slack variables to transform inequality constraints into equations for both rational and real LP, which should be in sync
|
|
void | _untransformEquality (SolRational &sol) |
| undoes transformation to equality form
|
|
void | _transformUnbounded () |
| transforms LP to unboundedness problem by moving the objective function to the constraints, changing right-hand side and bounds to zero, and adding an auxiliary variable for the decrease in the objective function
|
|
void | _untransformUnbounded (SolRational &sol, bool unbounded) |
| undoes transformation to unboundedness problem
|
|
void | _transformFeasibility () |
| transforms LP to feasibility problem by removing the objective function, shifting variables, and homogenizing the right-hand side
|
|
void | _untransformFeasibility (SolRational &sol, bool infeasible) |
| undoes transformation to feasibility problem
|
|
void | _computeInfeasBox (SolRational &sol, bool transformed) |
|
SPxSolverBase< R >::Status | _solveRealForRational (bool fromscratch, VectorBase< R > &primal, VectorBase< R > &dual, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusRows, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusCols) |
| solves real LP during iterative refinement
|
|
SPxSolverBase< R >::Status | _solveRealStable (bool acceptUnbounded, bool acceptInfeasible, VectorBase< R > &primal, VectorBase< R > &dual, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusRows, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusCols, const bool forceNoSimplifier=false) |
| solves real LP with recovery mechanism
|
|
void | _computeBasisInverseRational () |
| computes rational inverse of basis matrix as defined by _rationalLUSolverBind
|
|
void | _factorizeColumnRational (SolRational &sol, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusRows, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusCols, bool &stoppedTime, bool &stoppedIter, bool &error, bool &optimal) |
| factorizes rational basis matrix in column representation
|
|
bool | _reconstructSolutionRational (SolRational &sol, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusRows, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusCols, const Rational &denomBoundSquared) |
| attempts rational reconstruction of primal-dual solution
|
|
|
void | _optimize (volatile bool *interrupt=NULL) |
| solves the templated LP
|
|
void | _optimizeRational (volatile bool *interrupt=NULL) |
| temporary fix for Rational
|
|
void | _evaluateSolutionReal (typename SPxSimplifier< R >::Result simplificationStatus) |
| checks result of the solving process and solves again without preprocessing if necessary
|
|
void | _preprocessAndSolveReal (bool applyPreprocessing, volatile bool *interrupt=NULL) |
| solves real LP with/without preprocessing
|
|
void | _resolveWithoutPreprocessing (typename SPxSimplifier< R >::Result simplificationStatus) |
| loads original problem into solver and solves again after it has been solved to optimality with preprocessing
|
|
void | _verifySolutionReal () |
| verify computed solution and resolve if necessary
|
|
void | _storeSolutionReal (bool verify=true) |
| stores solution of the real LP; before calling this, the real LP must be loaded in the solver and solved (again)
|
|
void | _storeSolutionRealFromPresol () |
| stores solution from the simplifier because problem vanished in presolving step
|
|
void | _unscaleSolutionReal (SPxLPBase< R > &LP, bool persistent=true) |
| unscales stored solution to remove internal or external scaling of LP
|
|
void | _loadRealLP (bool initBasis) |
| load original LP and possibly setup a slack basis
|
|
void | _checkScaling (SPxLPBase< R > *origLP) const |
| check scaling of LP
|
|
void | _checkBasisScaling () |
| check correctness of (un)scaled basis matrix operations
|
|
bool | _reapplyPersistentScaling () const |
| check whether persistent scaling is supposed to be reapplied again after unscaling
|
|
void | _solveDecompositionDualSimplex () |
| solves LP using the decomposition based dual simplex
|
|
void | _createDecompReducedAndComplementaryProblems () |
| creating copies of the original problem that will be manipulated to form the reduced and complementary problems
|
|
void | _formDecompReducedProblem (bool &stop) |
| forms the reduced problem
|
|
void | _solveDecompReducedProblem () |
| solves the reduced problem
|
|
void | _formDecompComplementaryProblem () |
| forms the complementary problem
|
|
void | _decompSimplifyAndSolve (SPxSolverBase< R > &solver, SLUFactor< R > &sluFactor, bool fromScratch, bool applyPreprocessing) |
| simplifies the problem and solves
|
|
void | _decompResolveWithoutPreprocessing (SPxSolverBase< R > &solver, SLUFactor< R > &sluFactor, typename SPxSimplifier< R >::Result result) |
| loads original problem into solver and solves again after it has been solved to optimality with preprocessing
|
|
void | _getZeroDualMultiplierIndices (VectorBase< R > feasVector, int *nonposind, int *colsforremoval, int *nnonposind, bool &stop) |
| identifies the columns of the row-form basis that correspond to rows with zero dual multipliers.
|
|
void | _getCompatibleColumns (VectorBase< R > feasVector, int *nonposind, int *compatind, int *rowsforremoval, int *colsforremoval, int nnonposind, int *ncompatind, bool formRedProb, bool &stop) |
| retrieves the compatible columns from the constraint matrix
|
|
void | _computeReducedProbObjCoeff (bool &stop) |
| computes the reduced problem objective coefficients
|
|
void | _getCompatibleBoundCons (LPRowSetBase< R > &boundcons, int *compatboundcons, int *nonposind, int *ncompatboundcons, int nnonposind, bool &stop) |
| computes the compatible bound constraints and adds them to the reduced problem
|
|
void | _getRowsForRemovalComplementaryProblem (int *nonposind, int *bind, int *rowsforremoval, int *nrowsforremoval, int nnonposind) |
| computes the rows to remove from the complementary problem
|
|
void | _deleteAndUpdateRowsComplementaryProblem (SPxRowId rangedRowIds[], int &naddedrows) |
| removing rows from the complementary problem.
|
|
void | _evaluateSolutionDecomp (SPxSolverBase< R > &solver, SLUFactor< R > &sluFactor, typename SPxSimplifier< R >::Result result) |
| evaluates the solution of the reduced problem for the DBDS
|
|
void | _updateDecompReducedProblem (R objVal, VectorBase< R > dualVector, VectorBase< R > redcostVector, VectorBase< R > compPrimalVector, VectorBase< R > compDualVector) |
| update the reduced problem with additional columns and rows
|
|
void | _updateDecompReducedProblemViol (bool allrows) |
| update the reduced problem with additional columns and rows based upon the violated original bounds and rows
|
|
void | _findViolatedRows (R compObjValue, Array< RowViolation > &violatedrows, int &nviolatedrows) |
| builds the update rows with those violated in the complmentary problem
|
|
void | _updateDecompComplementaryDualProblem (bool origObj) |
| update the dual complementary problem with additional columns and rows
|
|
void | _updateDecompComplementaryPrimalProblem (bool origObj) |
| update the primal complementary problem with additional columns and rows
|
|
void | _checkOriginalProblemOptimality (VectorBase< R > primalVector, bool printViol) |
| checking the optimality of the original problem.
|
|
void | _updateComplementaryDualSlackColCoeff () |
| updating the slack column coefficients to adjust for equality constraints
|
|
void | _updateComplementaryPrimalSlackColCoeff () |
| updating the slack column coefficients to adjust for equality constraints
|
|
void | _removeComplementaryDualFixedPrimalVars (int *currFixedVars) |
| removing the dual columns related to the fixed variables
|
|
void | _identifyComplementaryDualFixedPrimalVars (int *currFixedVars) |
| removing the dual columns related to the fixed variables
|
|
void | _updateComplementaryDualFixedPrimalVars (int *currFixedVars) |
| updating the dual columns related to the fixed primal variables.
|
|
void | _identifyComplementaryPrimalFixedPrimalVars (int *currFixedVars) |
| removing the dual columns related to the fixed variables
|
|
void | _updateComplementaryPrimalFixedPrimalVars (int *currFixedVars) |
| updating the dual columns related to the fixed primal variables.
|
|
void | _setComplementaryDualOriginalObjective () |
| updating the complementary dual problem with the original objective function
|
|
void | _setComplementaryPrimalOriginalObjective () |
| updating the complementary primal problem with the original objective function
|
|
int | getOrigVarFixedDirection (int colNum) |
| determining which bound the primal variables will be fixed to.
|
|
bool | checkBasisDualFeasibility (VectorBase< R > feasVec) |
| checks the dual feasibility of the current basis
|
|
DualSign | getExpectedDualVariableSign (int rowNumber) |
| returns the expected sign of the dual variables for the reduced problem
|
|
DualSign | getOrigProbDualVariableSign (int rowNumber) |
| returns the expected sign of the dual variables for the original problem
|
|
void | printDecompDisplayLine (SPxSolverBase< R > &solver, const SPxOut::Verbosity origVerb, bool force, bool forceHead) |
| prints a display line of the flying table for the DBDS
|
|
void | getOriginalProblemStatistics () |
| stores the problem statistics of the original problem
|
|
void | printOriginalProblemStatistics (std::ostream &os) |
| stores the problem statistics of the original problem
|
|
R | getCompSlackVarCoeff (int primalRowNum) |
| gets the coefficient of the slack variable in the primal complementary problem
|
|
bool | getDecompBoundViolation (R &maxviol, R &sumviol) |
| gets violation of bounds; returns true on success
|
|
bool | getDecompRowViolation (R &maxviol, R &sumviol) |
| gets violation of constraints; returns true on success
|
|
bool | decompTerminate (R timeLimit) |
| function call to terminate the decomposition simplex
|
|
void | _writeOriginalProblemBasis (const char *filename, NameSet *rowNames, NameSet *colNames, bool cpxFormat) |
| function to build a basis for the original problem as given by the solution to the reduced problem
|
|
void | getOriginalProblemBasisRowStatus (DataArray< int > °enerateRowNums, DataArray< typename SPxSolverBase< R >::VarStatus > °enerateRowStatus, int &nDegenerateRows, int &nNonBasicRows) |
| function to retrieve the original problem row basis status from the reduced and complementary problems
|
|
void | getOriginalProblemBasisColStatus (int &nNonBasicCols) |
| function to retrieve the column status for the original problem basis from the reduced and complementary problems
|
|
|
enum | BoolParam {
LIFTING = 0
, EQTRANS = 1
, TESTDUALINF = 2
, RATFAC = 3
,
USEDECOMPDUALSIMPLEX = 4
, COMPUTEDEGEN = 5
, USECOMPDUAL = 6
, EXPLICITVIOL = 7
,
ACCEPTCYCLING = 8
, RATREC = 9
, POWERSCALING = 10
, RATFACJUMP = 11
,
ROWBOUNDFLIPS = 12
, PERSISTENTSCALING = 13
, FULLPERTURBATION = 14
, ENSURERAY = 15
,
FORCEBASIC = 16
, BOOLPARAM_COUNT = 17
} |
| boolean parameters More...
|
|
enum | IntParam {
OBJSENSE = 0
, REPRESENTATION = 1
, ALGORITHM = 2
, FACTOR_UPDATE_TYPE = 3
,
FACTOR_UPDATE_MAX = 4
, ITERLIMIT = 5
, REFLIMIT = 6
, STALLREFLIMIT = 7
,
DISPLAYFREQ = 8
, VERBOSITY = 9
, SIMPLIFIER = 10
, SCALER = 11
,
STARTER = 12
, PRICER = 13
, RATIOTESTER = 14
, SYNCMODE = 15
,
READMODE = 16
, SOLVEMODE = 17
, CHECKMODE = 18
, TIMER = 19
,
HYPER_PRICING = 20
, RATFAC_MINSTALLS = 21
, LEASTSQ_MAXROUNDS = 22
, SOLUTION_POLISHING = 23
,
DECOMP_ITERLIMIT = 24
, DECOMP_MAXADDEDROWS = 25
, DECOMP_DISPLAYFREQ = 26
, DECOMP_VERBOSITY = 27
,
PRINTBASISMETRIC = 28
, STATTIMER = 29
, INTPARAM_COUNT = 30
} |
| integer parameters More...
|
|
enum | { OBJSENSE_MINIMIZE = -1
, OBJSENSE_MAXIMIZE = 1
} |
| values for parameter OBJSENSE More...
|
|
enum | { REPRESENTATION_AUTO = 0
, REPRESENTATION_COLUMN = 1
, REPRESENTATION_ROW = 2
} |
| values for parameter REPRESENTATION More...
|
|
enum | { ALGORITHM_PRIMAL = 0
, ALGORITHM_DUAL = 1
} |
| values for parameter ALGORITHM More...
|
|
enum | { FACTOR_UPDATE_TYPE_ETA = 0
, FACTOR_UPDATE_TYPE_FT = 1
} |
| values for parameter FACTOR_UPDATE_TYPE More...
|
|
enum | {
VERBOSITY_ERROR = 0
, VERBOSITY_WARNING = 1
, VERBOSITY_DEBUG = 2
, VERBOSITY_NORMAL = 3
,
VERBOSITY_HIGH = 4
, VERBOSITY_FULL = 5
} |
| values for parameter VERBOSITY More...
|
|
enum | { SIMPLIFIER_OFF = 0
, SIMPLIFIER_INTERNAL = 3
, SIMPLIFIER_PAPILO = 2
, SIMPLIFIER_AUTO = 1
} |
| values for parameter SIMPLIFIER More...
|
|
enum | {
SCALER_OFF = 0
, SCALER_UNIEQUI = 1
, SCALER_BIEQUI = 2
, SCALER_GEO1 = 3
,
SCALER_GEO8 = 4
, SCALER_LEASTSQ = 5
, SCALER_GEOEQUI = 6
} |
| values for parameter SCALER More...
|
|
enum | { STARTER_OFF = 0
, STARTER_WEIGHT = 1
, STARTER_SUM = 2
, STARTER_VECTOR = 3
} |
| values for parameter STARTER More...
|
|
enum | {
PRICER_AUTO = 0
, PRICER_DANTZIG = 1
, PRICER_PARMULT = 2
, PRICER_DEVEX = 3
,
PRICER_QUICKSTEEP = 4
, PRICER_STEEP = 5
} |
| values for parameter PRICER More...
|
|
enum | { RATIOTESTER_TEXTBOOK = 0
, RATIOTESTER_HARRIS = 1
, RATIOTESTER_FAST = 2
, RATIOTESTER_BOUNDFLIPPING = 3
} |
| values for parameter RATIOTESTER More...
|
|
enum | { SYNCMODE_ONLYREAL = 0
, SYNCMODE_AUTO = 1
, SYNCMODE_MANUAL = 2
} |
| values for parameter SYNCMODE More...
|
|
enum | { READMODE_REAL = 0
, READMODE_RATIONAL = 1
} |
| values for parameter READMODE More...
|
|
enum | { SOLVEMODE_REAL = 0
, SOLVEMODE_AUTO = 1
, SOLVEMODE_RATIONAL = 2
} |
| values for parameter SOLVEMODE More...
|
|
enum | { CHECKMODE_REAL = 0
, CHECKMODE_AUTO = 1
, CHECKMODE_RATIONAL = 2
} |
| values for parameter CHECKMODE More...
|
|
enum | { TIMER_OFF = 0
, TIMER_CPU = 1
, TIMER_WALLCLOCK = 2
} |
| values for parameter TIMER More...
|
|
enum | { HYPER_PRICING_OFF = 0
, HYPER_PRICING_AUTO = 1
, HYPER_PRICING_ON = 2
} |
| values for parameter HYPER_PRICING More...
|
|
enum | { POLISHING_OFF = 0
, POLISHING_INTEGRALITY = 1
, POLISHING_FRACTIONALITY = 2
} |
| values for parameter SOLUTION_POLISHING More...
|
|
enum | RealParam {
FEASTOL = 0
, OPTTOL = 1
, EPSILON_ZERO = 2
, EPSILON_FACTORIZATION = 3
,
EPSILON_UPDATE = 4
, EPSILON_PIVOT = 5
, INFTY = 6
, TIMELIMIT = 7
,
OBJLIMIT_LOWER = 8
, OBJLIMIT_UPPER = 9
, FPFEASTOL = 10
, FPOPTTOL = 11
,
MAXSCALEINCR = 12
, LIFTMINVAL = 13
, LIFTMAXVAL = 14
, SPARSITY_THRESHOLD = 15
,
REPRESENTATION_SWITCH = 16
, RATREC_FREQ = 17
, MINRED = 18
, REFAC_BASIS_NNZ = 19
,
REFAC_UPDATE_FILL = 20
, REFAC_MEM_FACTOR = 21
, LEASTSQ_ACRCY = 22
, OBJ_OFFSET = 23
,
MIN_MARKOWITZ = 24
, SIMPLIFIER_MODIFYROWFAC = 25
, REALPARAM_COUNT = 26
} |
| real parameters More...
|
|
SPxOut | spxout |
|
bool | boolParam (const BoolParam param) const |
| returns boolean parameter value
|
|
int | intParam (const IntParam param) const |
| returns integer parameter value
|
|
Real | realParam (const RealParam param) const |
| returns real parameter value
|
|
const Settings & | settings () const |
| returns current parameter settings
|
|
bool | setBoolParam (const BoolParam param, const bool value, const bool init=true) |
| sets boolean parameter value; returns true on success
|
|
bool | setIntParam (const IntParam param, const int value, const bool init=true) |
| sets integer parameter value; returns true on success
|
|
bool | setRealParam (const RealParam param, const Real value, const bool init=true) |
| sets real parameter value; returns true on success
|
|
bool | setSettings (const Settings &newSettings, const bool init=true) |
| sets parameter settings; returns true on success
|
|
void | resetSettings (const bool quiet=false, const bool init=true) |
| resets default parameter settings
|
|
void | printUserSettings () |
| print non-default parameter values
|
|
bool | saveSettingsFile (const char *filename, const bool onlyChanged=false, int solvemode=1) const |
| writes settings file; returns true on success
|
|
bool | loadSettingsFile (const char *filename) |
| reads settings file; returns true on success
|
|
bool | parseSettingsString (char *str) |
| parses one setting string and returns true on success; note that string is modified
|
|
template< class R>
class soplex::SoPlexBase< R >
Definition at line 120 of file soplex.h.
◆ anonymous enum
values for parameter OBJSENSE
Enumerator |
---|
OBJSENSE_MINIMIZE | minimization
|
OBJSENSE_MAXIMIZE | maximization
|
Definition at line 1098 of file soplex.h.
◆ anonymous enum
values for parameter REPRESENTATION
Enumerator |
---|
REPRESENTATION_AUTO | automatic choice according to number of rows and columns
|
REPRESENTATION_COLUMN | column representation Ax - s = 0, lower <= x <= upper, lhs <= s <= rhs
|
REPRESENTATION_ROW | row representation (lower,lhs) <= (x,Ax) <= (upper,rhs)
|
Definition at line 1108 of file soplex.h.
◆ anonymous enum
values for parameter SYNCMODE
Enumerator |
---|
SYNCMODE_ONLYREAL | store only real LP
|
SYNCMODE_AUTO | automatic sync of real and rational LP
|
SYNCMODE_MANUAL | user sync of real and rational LP
|
Definition at line 1258 of file soplex.h.
◆ anonymous enum
values for parameter READMODE
Enumerator |
---|
READMODE_REAL | standard floating-point parsing
|
READMODE_RATIONAL | rational parsing
|
Definition at line 1271 of file soplex.h.
◆ anonymous enum
values for parameter SOLVEMODE
Enumerator |
---|
SOLVEMODE_REAL | apply standard floating-point algorithm
|
SOLVEMODE_AUTO | decide depending on tolerances whether to apply iterative refinement
|
SOLVEMODE_RATIONAL | force iterative refinement
|
Definition at line 1281 of file soplex.h.
◆ anonymous enum
values for parameter CHECKMODE
Enumerator |
---|
CHECKMODE_REAL | floating-point check
|
CHECKMODE_AUTO | decide according to READMODE
|
CHECKMODE_RATIONAL | rational check
|
Definition at line 1294 of file soplex.h.
◆ anonymous enum
values for parameter TIMER
Enumerator |
---|
TIMER_OFF | disable timing
|
TIMER_CPU | cpu or user time
|
TIMER_WALLCLOCK | wallclock time
|
Definition at line 1307 of file soplex.h.
◆ anonymous enum
values for parameter HYPER_PRICING
Enumerator |
---|
HYPER_PRICING_OFF | never
|
HYPER_PRICING_AUTO | decide according to problem size
|
HYPER_PRICING_ON | always
|
Definition at line 1320 of file soplex.h.
◆ anonymous enum
values for parameter SOLUTION_POLISHING
Enumerator |
---|
POLISHING_OFF | no solution polishing
|
POLISHING_INTEGRALITY | maximize number of basic slack variables, i.e. more variables on bounds
|
POLISHING_FRACTIONALITY | minimize number of basic slack variables, i.e. more variables between bounds
|
Definition at line 1333 of file soplex.h.
◆ anonymous enum
values for parameter ALGORITHM
Enumerator |
---|
ALGORITHM_PRIMAL | primal simplex algorithm, i.e., entering for column and leaving for row representation
|
ALGORITHM_DUAL | dual simplex algorithm, i.e., leaving for column and entering for row representation
|
Definition at line 1121 of file soplex.h.
◆ anonymous enum
values for parameter FACTOR_UPDATE_TYPE
Enumerator |
---|
FACTOR_UPDATE_TYPE_ETA | product form update
|
FACTOR_UPDATE_TYPE_FT | Forrest-Tomlin type update.
|
Definition at line 1131 of file soplex.h.
◆ anonymous enum
values for parameter VERBOSITY
Enumerator |
---|
VERBOSITY_ERROR | only error output
|
VERBOSITY_WARNING | only error and warning output
|
VERBOSITY_DEBUG | only error, warning, and debug output
|
VERBOSITY_NORMAL | standard verbosity level
|
VERBOSITY_HIGH | high verbosity level
|
VERBOSITY_FULL | full verbosity level
|
Definition at line 1141 of file soplex.h.
◆ anonymous enum
values for parameter SIMPLIFIER
Enumerator |
---|
SIMPLIFIER_OFF | disabling presolving
|
SIMPLIFIER_INTERNAL | using internal presolving methods
|
SIMPLIFIER_PAPILO | using the presolve lib papilo
|
SIMPLIFIER_AUTO | SoPlex chooses automatically (currently always "internal")
|
Definition at line 1163 of file soplex.h.
◆ anonymous enum
values for parameter SCALER
Enumerator |
---|
SCALER_OFF | no scaler
|
SCALER_UNIEQUI | equilibrium scaling on rows or columns
|
SCALER_BIEQUI | equilibrium scaling on rows and columns
|
SCALER_GEO1 | geometric mean scaling on rows and columns, max 1 round
|
SCALER_GEO8 | geometric mean scaling on rows and columns, max 8 rounds
|
SCALER_LEASTSQ | least square scaling
|
SCALER_GEOEQUI | geometric mean scaling (max 8 rounds) followed by equilibrium scaling (rows and columns)
|
Definition at line 1179 of file soplex.h.
◆ anonymous enum
values for parameter STARTER
Enumerator |
---|
STARTER_OFF | slack basis
|
STARTER_WEIGHT | greedy crash basis weighted by objective, bounds, and sides
|
STARTER_SUM | crash basis from a greedy solution
|
STARTER_VECTOR | generic solution-based crash basis
|
Definition at line 1204 of file soplex.h.
◆ anonymous enum
values for parameter PRICER
Enumerator |
---|
PRICER_AUTO | automatic pricer
|
PRICER_DANTZIG | Dantzig pricer.
|
PRICER_PARMULT | partial multiple pricer based on Dantzig pricing
|
PRICER_DEVEX | devex pricer
|
PRICER_QUICKSTEEP | steepest edge pricer with initialization to unit norms
|
PRICER_STEEP | steepest edge pricer with exact initialization of norms
|
Definition at line 1220 of file soplex.h.
◆ anonymous enum
values for parameter RATIOTESTER
Enumerator |
---|
RATIOTESTER_TEXTBOOK | textbook ratio test without stabilization
|
RATIOTESTER_HARRIS | standard Harris ratio test
|
RATIOTESTER_FAST | modified Harris ratio test
|
RATIOTESTER_BOUNDFLIPPING | bound flipping ratio test for long steps in the dual simplex
|
Definition at line 1242 of file soplex.h.
◆ BoolParam
boolean parameters
Enumerator |
---|
LIFTING | should lifting be used to reduce range of nonzero matrix coefficients?
|
EQTRANS | should LP be transformed to equality form before a rational solve?
|
TESTDUALINF | should dual infeasibility be tested in order to try to return a dual solution even if primal infeasible?
|
RATFAC | should a rational factorization be performed after iterative refinement?
|
USEDECOMPDUALSIMPLEX | should the decomposition based dual simplex be used to solve the LP? Setting this to true forces the solve mode to SOLVEMODE_REAL and the basis representation to REPRESENTATION_ROW
|
COMPUTEDEGEN | should the degeneracy be computed for each basis?
|
USECOMPDUAL | should the dual of the complementary problem be used in the decomposition simplex?
|
EXPLICITVIOL | should row and bound violations be computed explicitly in the update of reduced problem in the decomposition simplex
|
ACCEPTCYCLING | should cycling solutions be accepted during iterative refinement?
|
RATREC | apply rational reconstruction after each iterative refinement?
|
POWERSCALING | round scaling factors for iterative refinement to powers of two?
|
RATFACJUMP | continue iterative refinement with exact basic solution if not optimal?
|
ROWBOUNDFLIPS | use bound flipping also for row representation?
|
PERSISTENTSCALING | use persistent scaling?
|
FULLPERTURBATION | perturb the entire problem or only the relevant bounds of s single pivot?
|
ENSURERAY | re-optimize the original problem to get a proof (ray) of infeasibility/unboundedness?
|
FORCEBASIC | try to enforce that the optimal solution is a basic solutiong
|
BOOLPARAM_COUNT | number of boolean parameters
|
Definition at line 942 of file soplex.h.
◆ decompStatus
Enumerator |
---|
DECOMP_ORIG | |
DECOMP_RED | |
DECOMP_COMP | |
Definition at line 1797 of file soplex.h.
◆ DualSign
Enumerator |
---|
IS_POS | |
IS_NEG | |
IS_FREE | |
Definition at line 1810 of file soplex.h.
◆ IntParam
integer parameters
Enumerator |
---|
OBJSENSE | objective sense
|
REPRESENTATION | type of computational form, i.e., column or row representation
|
ALGORITHM | type of algorithm, i.e., primal or dual
|
FACTOR_UPDATE_TYPE | type of LU update
|
FACTOR_UPDATE_MAX | maximum number of updates without fresh factorization
|
ITERLIMIT | iteration limit (-1 if unlimited)
|
REFLIMIT | refinement limit (-1 if unlimited)
|
STALLREFLIMIT | stalling refinement limit (-1 if unlimited)
|
DISPLAYFREQ | display frequency
|
VERBOSITY | verbosity level
|
SIMPLIFIER | type of simplifier
|
SCALER | type of scaler
|
STARTER | type of starter used to create crash basis
|
PRICER | type of pricer
|
RATIOTESTER | type of ratio test
|
SYNCMODE | mode for synchronizing real and rational LP
|
READMODE | mode for reading LP files
|
SOLVEMODE | mode for iterative refinement strategy
|
CHECKMODE | mode for a posteriori feasibility checks
|
TIMER | type of timer
|
HYPER_PRICING | mode for hyper sparse pricing
|
RATFAC_MINSTALLS | minimum number of stalling refinements since last pivot to trigger rational factorization
|
LEASTSQ_MAXROUNDS | maximum number of conjugate gradient iterations in least square scaling
|
SOLUTION_POLISHING | mode for solution polishing
|
DECOMP_ITERLIMIT | the number of iterations before the decomposition simplex initialisation is terminated.
|
DECOMP_MAXADDEDROWS | the maximum number of rows that are added in each iteration of the decomposition based simplex
|
DECOMP_DISPLAYFREQ | the iteration frequency at which the decomposition solve output is displayed.
|
DECOMP_VERBOSITY | the verbosity of the decomposition based simplex
|
PRINTBASISMETRIC | print condition number during the solve
|
STATTIMER | type of timer for statistics
|
INTPARAM_COUNT | number of integer parameters
|
Definition at line 1001 of file soplex.h.
◆ RangeType
type of bounds and sides
Enumerator |
---|
RANGETYPE_FREE | both bounds are infinite
|
RANGETYPE_LOWER | lower bound is finite, upper bound is infinite
|
RANGETYPE_UPPER | upper bound is finite, lower bound is infinite
|
RANGETYPE_BOXED | lower and upper bound finite, but different
|
RANGETYPE_FIXED | lower bound equals upper bound
|
Definition at line 1738 of file soplex.h.
◆ RealParam
real parameters
Enumerator |
---|
FEASTOL | primal feasibility tolerance
|
OPTTOL | dual feasibility tolerance
|
EPSILON_ZERO | general zero tolerance
|
EPSILON_FACTORIZATION | zero tolerance used in factorization
|
EPSILON_UPDATE | zero tolerance used in update of the factorization
|
EPSILON_PIVOT | pivot zero tolerance used in factorization
|
INFTY | infinity threshold
|
TIMELIMIT | time limit in seconds (INFTY if unlimited)
|
OBJLIMIT_LOWER | lower limit on objective value
|
OBJLIMIT_UPPER | upper limit on objective value
|
FPFEASTOL | working tolerance for feasibility in floating-point solver during iterative refinement
|
FPOPTTOL | working tolerance for optimality in floating-point solver during iterative refinement
|
MAXSCALEINCR | maximum increase of scaling factors between refinements
|
LIFTMINVAL | lower threshold in lifting (nonzero matrix coefficients with smaller absolute value will be reformulated)
|
LIFTMAXVAL | upper threshold in lifting (nonzero matrix coefficients with larger absolute value will be reformulated)
|
SPARSITY_THRESHOLD | sparse pricing threshold (#violations < dimension * SPARSITY_THRESHOLD activates sparse pricing)
|
REPRESENTATION_SWITCH | threshold on number of rows vs. number of columns for switching from column to row representations in auto mode
|
RATREC_FREQ | geometric frequency at which to apply rational reconstruction
|
MINRED | minimal reduction (sum of removed rows/cols) to continue simplification
|
REFAC_BASIS_NNZ | refactor threshold for nonzeros in last factorized basis matrix compared to updated basis matrix
|
REFAC_UPDATE_FILL | refactor threshold for fill-in in current factor update compared to fill-in in last factorization
|
REFAC_MEM_FACTOR | refactor threshold for memory growth in factorization since last refactorization
|
LEASTSQ_ACRCY | accuracy of conjugate gradient method in least squares scaling (higher value leads to more iterations)
|
OBJ_OFFSET | objective offset
|
MIN_MARKOWITZ | minimal Markowitz threshold to control sparsity/stability in LU factorization
|
SIMPLIFIER_MODIFYROWFAC | minimal modification threshold to apply presolve reductions
|
REALPARAM_COUNT | number of real parameters
|
Definition at line 1346 of file soplex.h.
◆ SoPlexBase() [1/2]
◆ SoPlexBase() [2/2]
◆ ~SoPlexBase()
◆ _addColReal() [1/2]
adds a single column to the real LP and adjusts basis
◆ _addColReal() [2/2]
adds a single column to the real LP and adjusts basis
◆ _addColsReal()
adds multiple columns to the real LP and adjusts basis
◆ _addRowReal() [1/2]
adds a single row to the real LP and adjusts basis
◆ _addRowReal() [2/2]
adds a single row to the real LP and adjusts basis
◆ _addRowsReal()
adds multiple rows to the real LP and adjusts basis
◆ _changeBoundsReal() [1/2]
changes vectors of column bounds to lower and upper and adjusts basis
◆ _changeBoundsReal() [2/2]
changes bounds of column i to lower and upper and adjusts basis
◆ _changeColReal()
replaces column i with lpcol and adjusts basis
◆ _changeElementReal()
changes matrix entry in row i and column j to val and adjusts basis
◆ _changeLhsReal() [1/2]
changes left-hand side vector for constraints to lhs and adjusts basis
◆ _changeLhsReal() [2/2]
changes left-hand side of row i to lhs and adjusts basis
◆ _changeLowerReal() [1/2]
changes vector of lower bounds to lower and adjusts basis
◆ _changeLowerReal() [2/2]
changes lower bound of column i to lower and adjusts basis
◆ _changeRangeReal() [1/2]
changes left- and right-hand side vectors and adjusts basis
◆ _changeRangeReal() [2/2]
changes left- and right-hand side of row i and adjusts basis
◆ _changeRhsReal() [1/2]
changes right-hand side vector to rhs and adjusts basis
◆ _changeRhsReal() [2/2]
changes right-hand side of row i to rhs and adjusts basis
◆ _changeRowReal()
replaces row i with lprow and adjusts basis
◆ _changeUpperReal() [1/2]
changes vector of upper bounds to upper and adjusts basis
◆ _changeUpperReal() [2/2]
changes i 'th upper bound to upper and adjusts basis
◆ _checkBasisScaling()
void _checkBasisScaling |
( |
| ) |
|
|
private |
check correctness of (un)scaled basis matrix operations
◆ _checkOriginalProblemOptimality()
checking the optimality of the original problem.
◆ _checkScaling()
◆ _completeRangeTypesRational()
void _completeRangeTypesRational |
( |
| ) |
|
|
private |
completes range type arrays after adding columns and/or rows
◆ _computeBasisInverseRational()
void _computeBasisInverseRational |
( |
| ) |
|
|
private |
computes rational inverse of basis matrix as defined by _rationalLUSolverBind
◆ _computeInfeasBox()
computes radius of infeasibility box implied by an approximate Farkas' proof
Given constraints of the form \( lhs <= Ax <= rhs \), a farkas proof y should satisfy \( y^T A = 0 \) and \( y_+^T lhs - y_-^T rhs > 0 \), where \( y_+, y_- \) denote the positive and negative parts of \( y \). If \( y \) is approximate, it may not satisfy \( y^T A = 0 \) exactly, but the proof is still valid as long as the following holds for all potentially feasible \( x \):
\[
y^T Ax < (y_+^T lhs - y_-^T rhs) (*)
\]
we may therefore calculate \( y^T A \) and \( y_+^T lhs - y_-^T rhs \) exactly and check if the upper and lower bounds on \( x \) imply that all feasible \( x \) satisfy (*), and if not then compute bounds on \( x \) to guarantee (*). The simplest way to do this is to compute
\[
B = (y_+^T lhs - y_-^T rhs) / \sum_i(|(y^T A)_i|)
\]
noting that if every component of \( x \) has \( |x_i| < B \), then (*) holds.
\( B \) can be increased by iteratively including variable bounds smaller than \( B \). The speed of this method can be further improved by using interval arithmetic for all computations. For related information see Sec. 4 of Neumaier and Shcherbina, Mathematical Programming A, 2004.
Set transformed to true if this method is called after _transformFeasibility().
◆ _computeReducedProbObjCoeff()
void _computeReducedProbObjCoeff |
( |
bool & | stop | ) |
|
|
private |
computes the reduced problem objective coefficients
◆ _createDecompReducedAndComplementaryProblems()
void _createDecompReducedAndComplementaryProblems |
( |
| ) |
|
|
private |
creating copies of the original problem that will be manipulated to form the reduced and complementary problems
◆ _decompResolveWithoutPreprocessing()
loads original problem into solver and solves again after it has been solved to optimality with preprocessing
◆ _decompSimplifyAndSolve()
simplifies the problem and solves
◆ _deleteAndUpdateRowsComplementaryProblem()
void _deleteAndUpdateRowsComplementaryProblem |
( |
SPxRowId | rangedRowIds[], |
|
|
int & | naddedrows ) |
|
private |
removing rows from the complementary problem.
◆ _disableSimplifierAndScaler()
void _disableSimplifierAndScaler |
( |
| ) |
|
|
private |
disables simplifier and scaler
◆ _enableSimplifierAndScaler()
void _enableSimplifierAndScaler |
( |
| ) |
|
|
private |
enables simplifier and scaler according to current parameters
◆ _ensureDSVectorRationalMemory()
extends sparse vector to hold newmax entries if and only if it holds no more free entries
◆ _ensureRationalLP()
void _ensureRationalLP |
( |
| ) |
|
|
private |
ensures that the rational LP is available; performs no sync
◆ _ensureRealLPLoaded()
void _ensureRealLPLoaded |
( |
| ) |
|
|
private |
ensures that the real LP and the basis are loaded in the solver; performs no sync
◆ _evaluateSolutionDecomp()
evaluates the solution of the reduced problem for the DBDS
◆ _evaluateSolutionReal()
checks result of the solving process and solves again without preprocessing if necessary
◆ _factorizeColumnRational()
factorizes rational basis matrix in column representation
◆ _findViolatedRows()
builds the update rows with those violated in the complmentary problem
◆ _formDecompComplementaryProblem()
void _formDecompComplementaryProblem |
( |
| ) |
|
|
private |
forms the complementary problem
◆ _formDecompReducedProblem()
void _formDecompReducedProblem |
( |
bool & | stop | ) |
|
|
private |
forms the reduced problem
◆ _getCompatibleBoundCons()
computes the compatible bound constraints and adds them to the reduced problem
◆ _getCompatibleColumns()
retrieves the compatible columns from the constraint matrix
◆ _getRowsForRemovalComplementaryProblem()
void _getRowsForRemovalComplementaryProblem |
( |
int * | nonposind, |
|
|
int * | bind, |
|
|
int * | rowsforremoval, |
|
|
int * | nrowsforremoval, |
|
|
int | nnonposind ) |
|
private |
computes the rows to remove from the complementary problem
◆ _getZeroDualMultiplierIndices()
identifies the columns of the row-form basis that correspond to rows with zero dual multipliers.
◆ _identifyComplementaryDualFixedPrimalVars()
void _identifyComplementaryDualFixedPrimalVars |
( |
int * | currFixedVars | ) |
|
|
private |
removing the dual columns related to the fixed variables
◆ _identifyComplementaryPrimalFixedPrimalVars()
void _identifyComplementaryPrimalFixedPrimalVars |
( |
int * | currFixedVars | ) |
|
|
private |
removing the dual columns related to the fixed variables
◆ _idxToPerm()
creates a permutation for removing rows/columns from an array of indices
◆ _invalidateSolution()
void _invalidateSolution |
( |
| ) |
|
|
private |
◆ _isConsistent()
bool _isConsistent |
( |
| ) |
const |
|
private |
◆ _isSolveStopped()
bool _isSolveStopped |
( |
bool & | stoppedTime, |
|
|
bool & | stoppedIter ) const |
|
private |
should solving process be stopped?
◆ _lift()
reduces matrix coefficient in absolute value by the lifting procedure of Thiele et al. 2013
◆ _loadRealLP()
load original LP and possibly setup a slack basis
◆ _lowerFinite()
checks whether RangeType corresponds to finite lower bound
◆ _optimize()
◆ _optimizeRational()
◆ _parseSettingsLine()
parses one line in a settings file and returns true on success; note that the string is modified
◆ _performFeasIRStable()
performs iterative refinement on the auxiliary problem for testing feasibility
◆ _performOptIRStable()
void _performOptIRStable |
( |
SolRational & | sol, |
|
|
bool | acceptUnbounded, |
|
|
bool | acceptInfeasible, |
|
|
int | minRounds, |
|
|
bool & | primalFeasible, |
|
|
bool & | dualFeasible, |
|
|
bool & | infeasible, |
|
|
bool & | unbounded, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
solves current problem with iterative refinement and recovery mechanism
◆ _performUnboundedIRStable()
performs iterative refinement on the auxiliary problem for testing unboundedness
◆ _preprocessAndSolveReal()
solves real LP with/without preprocessing
◆ _project()
◆ _rangeToPerm()
creates a permutation for removing rows/columns from a range of indices
◆ _rangeTypeRational()
determines RangeType from rational bounds
◆ _rangeTypeReal()
determines RangeType from real bounds
◆ _readFileRational()
reads rational LP in LP or MPS format from file and returns true on success; gets row names, column names, and integer variables if desired
◆ _readFileReal()
reads real LP in LP or MPS format from file and returns true on success; gets row names, column names, and integer variables if desired
◆ _reapplyPersistentScaling()
bool _reapplyPersistentScaling |
( |
| ) |
const |
|
private |
check whether persistent scaling is supposed to be reapplied again after unscaling
◆ _recomputeRangeTypesRational()
void _recomputeRangeTypesRational |
( |
| ) |
|
|
private |
recomputes range types from scratch using rational LP
◆ _recomputeRangeTypesReal()
void _recomputeRangeTypesReal |
( |
| ) |
|
|
private |
recomputes range types from scratch using real LP
◆ _reconstructSolutionRational()
attempts rational reconstruction of primal-dual solution
◆ _removeColRangeReal()
removes columns start to end including both; an array perm of size numColsReal() may be passed as buffer memory
◆ _removeColReal()
◆ _removeColsReal() [1/2]
remove all columns with indices in array idx of size n ; an array perm of size numColsReal() may be passed as buffer memory
◆ _removeColsReal() [2/2]
removes all columns with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where column i has been moved to; note that perm must point to an array of size at least numColsReal()
◆ _removeComplementaryDualFixedPrimalVars()
void _removeComplementaryDualFixedPrimalVars |
( |
int * | currFixedVars | ) |
|
|
private |
removing the dual columns related to the fixed variables
◆ _removeRowRangeReal()
removes rows start to end including both; an array perm of size numRows() may be passed as buffer memory
◆ _removeRowReal()
removes row i and adjusts basis
◆ _removeRowsReal() [1/2]
remove all rows with indices in array idx of size n ; an array perm of size numRows() may be passed as buffer memory
◆ _removeRowsReal() [2/2]
removes all rows with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where row i has been moved to; note that perm must point to an array of size at least numRows()
◆ _resolveWithoutPreprocessing()
loads original problem into solver and solves again after it has been solved to optimality with preprocessing
◆ _restoreBasis()
◆ _restoreLPReal()
restores objective, bounds, and sides of real LP
◆ _setComplementaryDualOriginalObjective()
void _setComplementaryDualOriginalObjective |
( |
| ) |
|
|
private |
updating the complementary dual problem with the original objective function
◆ _setComplementaryPrimalOriginalObjective()
void _setComplementaryPrimalOriginalObjective |
( |
| ) |
|
|
private |
updating the complementary primal problem with the original objective function
◆ _solveDecompositionDualSimplex()
void _solveDecompositionDualSimplex |
( |
| ) |
|
|
private |
solves LP using the decomposition based dual simplex
◆ _solveDecompReducedProblem()
void _solveDecompReducedProblem |
( |
| ) |
|
|
private |
solves the reduced problem
◆ _solveRealForRational()
solves real LP during iterative refinement
◆ _solveRealLPAndRecordStatistics()
call floating-point solver and update statistics on iterations etc.
◆ _solveRealStable()
solves real LP with recovery mechanism
◆ _storeBasis()
◆ _storeLPReal()
stores objective, bounds, and sides of real LP
◆ _storeSolutionReal()
stores solution of the real LP; before calling this, the real LP must be loaded in the solver and solved (again)
◆ _storeSolutionRealFromPresol()
void _storeSolutionRealFromPresol |
( |
| ) |
|
|
private |
stores solution from the simplifier because problem vanished in presolving step
◆ _switchRangeType()
switches RANGETYPE_LOWER to RANGETYPE_UPPER and vice versa
◆ _syncLPRational()
synchronizes rational LP with real LP, i.e., copies real LP to rational LP, without looking at the sync mode
◆ _syncLPReal()
synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, without looking at the sync mode
◆ _syncRationalSolution()
void _syncRationalSolution |
( |
| ) |
|
|
private |
synchronizes real solution with rational solution, i.e., copies real solution to rational solution
◆ _syncRealSolution()
void _syncRealSolution |
( |
| ) |
|
|
private |
synchronizes rational solution with real solution, i.e., copies (rounded) rational solution to real solution
◆ _transformEquality()
void _transformEquality |
( |
| ) |
|
|
private |
introduces slack variables to transform inequality constraints into equations for both rational and real LP, which should be in sync
◆ _transformFeasibility()
void _transformFeasibility |
( |
| ) |
|
|
private |
transforms LP to feasibility problem by removing the objective function, shifting variables, and homogenizing the right-hand side
◆ _transformUnbounded()
void _transformUnbounded |
( |
| ) |
|
|
private |
transforms LP to unboundedness problem by moving the objective function to the constraints, changing right-hand side and bounds to zero, and adding an auxiliary variable for the decrease in the objective function
◆ _unitVectorRational()
returns pointer to a constant unit vector available until destruction of the SoPlexBase class
◆ _unscaleSolutionReal()
unscales stored solution to remove internal or external scaling of LP
◆ _untransformEquality()
undoes transformation to equality form
◆ _untransformFeasibility()
undoes transformation to feasibility problem
◆ _untransformUnbounded()
undoes transformation to unboundedness problem
◆ _updateComplementaryDualFixedPrimalVars()
void _updateComplementaryDualFixedPrimalVars |
( |
int * | currFixedVars | ) |
|
|
private |
updating the dual columns related to the fixed primal variables.
◆ _updateComplementaryDualSlackColCoeff()
void _updateComplementaryDualSlackColCoeff |
( |
| ) |
|
|
private |
updating the slack column coefficients to adjust for equality constraints
◆ _updateComplementaryPrimalFixedPrimalVars()
void _updateComplementaryPrimalFixedPrimalVars |
( |
int * | currFixedVars | ) |
|
|
private |
updating the dual columns related to the fixed primal variables.
◆ _updateComplementaryPrimalSlackColCoeff()
void _updateComplementaryPrimalSlackColCoeff |
( |
| ) |
|
|
private |
updating the slack column coefficients to adjust for equality constraints
◆ _updateDecompComplementaryDualProblem()
void _updateDecompComplementaryDualProblem |
( |
bool | origObj | ) |
|
|
private |
update the dual complementary problem with additional columns and rows
◆ _updateDecompComplementaryPrimalProblem()
void _updateDecompComplementaryPrimalProblem |
( |
bool | origObj | ) |
|
|
private |
update the primal complementary problem with additional columns and rows
◆ _updateDecompReducedProblem()
update the reduced problem with additional columns and rows
◆ _updateDecompReducedProblemViol()
void _updateDecompReducedProblemViol |
( |
bool | allrows | ) |
|
|
private |
update the reduced problem with additional columns and rows based upon the violated original bounds and rows
◆ _upperFinite()
checks whether RangeType corresponds to finite upper bound
◆ _verifySolutionReal()
void _verifySolutionReal |
( |
| ) |
|
|
private |
verify computed solution and resolve if necessary
◆ _writeOriginalProblemBasis()
function to build a basis for the original problem as given by the solution to the reduced problem
◆ addColRational() [1/2]
◆ addColRational() [2/2]
adds a single column (GMP only method)
◆ addColReal()
◆ addColsRational() [1/2]
◆ addColsRational() [2/2]
adds a set of columns (GMP only method)
◆ addColsReal()
◆ addRowRational() [1/2]
◆ addRowRational() [2/2]
adds a single row (GMP only method)
◆ addRowReal()
◆ addRowsRational() [1/2]
◆ addRowsRational() [2/2]
adds a set of rows (GMP only method)
◆ addRowsReal()
◆ areLPsInSync()
checks if real LP and rational LP are in sync; dimensions will always be compared, vector and matrix values only if the respective parameter is set to true. If quiet is set to true the function will only display which vectors are different.
◆ basisColStatus()
returns basis status for a single column
◆ basisRowStatus()
returns basis status for a single row
◆ basisStatus()
returns the current basis status
◆ boolParam()
returns boolean parameter value
◆ changeBoundsRational() [1/3]
changes vectors of column bounds to lower and upper
◆ changeBoundsRational() [2/3]
changes bounds of column i to lower and upper (GMP only method)
◆ changeBoundsRational() [3/3]
changes bounds of column i to lower and upper
◆ changeBoundsReal() [1/2]
changes vectors of column bounds to lower and upper
◆ changeBoundsReal() [2/2]
changes bounds of column i to lower and upper
◆ changeColRational()
replaces column i with lpcol
◆ changeColReal()
replaces column i with lpcol
◆ changeElementRational() [1/2]
changes matrix entry in row i and column j to val (GMP only method)
◆ changeElementRational() [2/2]
changes matrix entry in row i and column j to val
◆ changeElementReal()
changes matrix entry in row i and column j to val
◆ changeLhsRational() [1/3]
changes left-hand side vector for constraints to lhs
◆ changeLhsRational() [2/3]
changes left-hand side of row i to lhs (GMP only method)
◆ changeLhsRational() [3/3]
changes left-hand side of row i to lhs
◆ changeLhsReal() [1/2]
changes left-hand side vector for constraints to lhs
◆ changeLhsReal() [2/2]
changes left-hand side of row i to lhs
◆ changeLowerRational() [1/3]
changes vector of lower bounds to lower
◆ changeLowerRational() [2/3]
changes lower bound of column i to lower (GMP only method)
◆ changeLowerRational() [3/3]
changes lower bound of column i to lower
◆ changeLowerReal() [1/2]
changes vector of lower bounds to lower
◆ changeLowerReal() [2/2]
changes lower bound of column i to lower
◆ changeObjRational() [1/3]
changes objective function vector to obj
◆ changeObjRational() [2/3]
changes objective coefficient of column i to obj (GMP only method)
◆ changeObjRational() [3/3]
changes objective coefficient of column i to obj
◆ changeObjReal() [1/2]
changes objective function vector to obj
◆ changeObjReal() [2/2]
changes objective coefficient of column i to obj
◆ changeRangeRational() [1/3]
changes left- and right-hand side vectors
◆ changeRangeRational() [2/3]
changes left- and right-hand side of row i (GMP only method)
◆ changeRangeRational() [3/3]
changes left- and right-hand side of row i
◆ changeRangeReal() [1/2]
changes left- and right-hand side vectors
◆ changeRangeReal() [2/2]
changes left- and right-hand side of row i
◆ changeRhsRational() [1/3]
changes right-hand side vector to rhs (GMP only method)
◆ changeRhsRational() [2/3]
changes right-hand side vector to rhs
◆ changeRhsRational() [3/3]
changes right-hand side of row i to rhs
◆ changeRhsReal() [1/2]
changes right-hand side vector to rhs
◆ changeRhsReal() [2/2]
changes right-hand side of row i to rhs
◆ changeRowRational()
replaces row i with lprow
◆ changeRowReal()
replaces row i with lprow
◆ changeUpperRational() [1/3]
changes vector of upper bounds to upper
◆ changeUpperRational() [2/3]
changes upper bound of column i to upper (GMP only method)
◆ changeUpperRational() [3/3]
changes i 'th upper bound to upper
◆ changeUpperReal() [1/2]
changes vector of upper bounds to upper
◆ changeUpperReal() [2/2]
changes i 'th upper bound to upper
◆ checkBasisDualFeasibility()
checks the dual feasibility of the current basis
◆ clearBasis()
◆ clearLPRational()
◆ clearLPReal()
◆ coefReal()
R coefReal |
( |
int | row, |
|
|
int | col ) const |
returns (unscaled) coefficient
◆ colVectorRational()
returns vector of column i
◆ colVectorRealInternal()
returns vector of col i , ignoring scaling
◆ computeBasisInverseRational()
bool computeBasisInverseRational |
( |
| ) |
|
compute rational basis inverse; returns true on success
◆ decompTerminate()
bool decompTerminate |
( |
R | timeLimit | ) |
|
|
private |
function call to terminate the decomposition simplex
◆ dlcmSizeDualRational()
get size of least common multiple of denominators in dual solution
◆ dlcmSizePrimalRational()
get size of least common multiple of denominators in primal solution
◆ dmaxSizeDualRational()
get size of largest denominator in dual solution
◆ dmaxSizePrimalRational()
get size of largest denominator in primal solution
◆ getBasis()
gets current basis via arrays of statuses
◆ getBasisInd()
void getBasisInd |
( |
int * | bind | ) |
const |
gets the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m
◆ getBasisIndRational()
gets an array of indices for the columns of the rational basis matrix; bind[i] >= 0 means that the i-th column of the basis matrix contains variable bind[i]; bind[i] < 0 means that the i-th column of the basis matrix contains the slack variable for row -bind[i]-1; performs rational factorization if not available; returns true on success
◆ getBasisInverseColRational()
computes column c of basis inverse; performs rational factorization if not available; returns true on success
◆ getBasisInverseColReal()
computes column c of basis inverse; returns true on success
- Parameters
-
c | which column of the basis inverse is computed |
coef | values of result vector (not packed but scattered) |
inds | indices of result vector (NULL if not to be used) |
ninds | number of nonzeros in result vector |
unscale | determines whether the result should be unscaled according to the original LP data |
◆ getBasisInverseRowRational()
computes row r of basis inverse; performs rational factorization if not available; returns true on success
◆ getBasisInverseRowReal()
computes row r of basis inverse; returns true on success
- Parameters
-
r | which row of the basis inverse is computed |
coef | values of result vector (not packed but scattered) |
inds | indices of result vector (NULL if not to be used) |
ninds | number of nonzeros in result vector |
unscale | determines whether the result should be unscaled according to the original LP data |
◆ getBasisInverseTimesVecRational()
computes solution of basis matrix B * sol = rhs; performs rational factorization if not available; returns true on success
◆ getBasisInverseTimesVecReal()
bool getBasisInverseTimesVecReal |
( |
R * | rhs, |
|
|
R * | sol, |
|
|
bool | unscale = true ) |
computes dense solution of basis matrix B * sol = rhs ; returns true on success
◆ getBasisMetric()
bool getBasisMetric |
( |
R & | metric, |
|
|
int | type = 0 ) |
compute one of several matrix metrics based on the diagonal of the LU factorization type = 0: max/min ratio type = 1: trace of U (sum of diagonal elements) type = 2: determinant (product of diagonal elements)
◆ getBoundViolation()
bool getBoundViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of bounds; returns true on success
◆ getBoundViolationRational()
◆ getColRational()
◆ getColsRational()
gets columns start , ..., end
◆ getColVectorReal()
◆ getCompSlackVarCoeff()
R getCompSlackVarCoeff |
( |
int | primalRowNum | ) |
|
|
private |
gets the coefficient of the slack variable in the primal complementary problem
◆ getDecompBoundViolation()
bool getDecompBoundViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
|
private |
gets violation of bounds; returns true on success
◆ getDecompRowViolation()
bool getDecompRowViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
|
private |
gets violation of constraints; returns true on success
◆ getDual()
gets the dual solution vector if available; returns true on success
◆ getDualFarkas()
gets the Farkas proof if available; returns true on success
◆ getDualFarkasRational() [1/2]
gets the Farkas proof if LP is infeasible; returns true on success (GMP only method)
◆ getDualFarkasRational() [2/2]
◆ getDualFarkasReal()
bool getDualFarkasReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getDualNorms()
bool getDualNorms |
( |
int & | nnormsRow, |
|
|
int & | nnormsCol, |
|
|
R * | norms ) const |
gets steepest edge norms and returns false if they are not available
◆ getDualRational() [1/2]
gets the dual solution vector if available; returns true on success (GMP only method)
◆ getDualRational() [2/2]
◆ getDualReal()
bool getDualReal |
( |
R * | p_vector, |
|
|
int | dim ) |
◆ getDualViolation()
bool getDualViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of dual multipliers; returns true on success
◆ getDualViolationRational()
◆ getEstimatedCondition()
bool getEstimatedCondition |
( |
R & | condition | ) |
|
computes an estimated condition number for the current basis matrix using the power method; returns true on success
◆ getExactCondition()
bool getExactCondition |
( |
R & | condition | ) |
|
computes the exact condition number for the current basis matrix using the power method; returns true on success
◆ getExpectedDualVariableSign()
returns the expected sign of the dual variables for the reduced problem
◆ getLhsReal()
gets left-hand side vector
◆ getLowerReal()
◆ getNdualNorms()
void getNdualNorms |
( |
int & | nnormsRow, |
|
|
int & | nnormsCol ) const |
gets number of available dual norms
◆ getObjRational() [1/2]
gets objective value of column i
◆ getObjRational() [2/2]
gets objective function vector
◆ getObjReal()
gets objective function vector
◆ getOriginalProblemBasisColStatus()
void getOriginalProblemBasisColStatus |
( |
int & | nNonBasicCols | ) |
|
|
private |
function to retrieve the column status for the original problem basis from the reduced and complementary problems
◆ getOriginalProblemBasisRowStatus()
function to retrieve the original problem row basis status from the reduced and complementary problems
◆ getOriginalProblemStatistics()
void getOriginalProblemStatistics |
( |
| ) |
|
|
private |
stores the problem statistics of the original problem
◆ getOrigProbDualVariableSign()
returns the expected sign of the dual variables for the original problem
◆ getOrigVarFixedDirection()
int getOrigVarFixedDirection |
( |
int | colNum | ) |
|
|
private |
determining which bound the primal variables will be fixed to.
◆ getPricerName()
name of currently loaded pricer
◆ getPrimal()
gets the primal solution vector if available; returns true on success
◆ getPrimalRational() [1/2]
gets the primal solution vector if available; returns true on success (GMP only method)
◆ getPrimalRational() [2/2]
◆ getPrimalRay()
gets the primal ray if available; returns true on success
◆ getPrimalRayRational() [1/2]
gets the primal ray if LP is unbounded; returns true on success (GMP only method)
◆ getPrimalRayRational() [2/2]
◆ getPrimalRayReal()
bool getPrimalRayReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getPrimalReal()
bool getPrimalReal |
( |
R * | p_vector, |
|
|
int | size ) |
◆ getRatiotesterName()
name of currently loaded ratiotester
◆ getRedCost()
gets the vector of reduced cost values if available; returns true on success
◆ getRedCostRational() [1/2]
gets the vector of reduced cost values if available; returns true on success (GMP only method)
◆ getRedCostRational() [2/2]
◆ getRedCostReal()
bool getRedCostReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getRedCostViolation()
bool getRedCostViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of reduced costs; returns true on success
◆ getRedCostViolationRational()
◆ getRhsReal()
gets right-hand side vector
◆ getRowRational()
◆ getRowsRational()
gets rows start , ..., end .
◆ getRowVectorReal()
◆ getRowViolation()
bool getRowViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of constraints; returns true on success
◆ getRowViolationRational()
◆ getScalerName()
◆ getSimplifierName()
◆ getSlacksRational() [1/2]
gets the vector of slack values if available; returns true on success (GMP only method)
◆ getSlacksRational() [2/2]
gets the vector of slack values if available; returns true on success
◆ getSlacksReal() [1/2]
bool getSlacksReal |
( |
R * | p_vector, |
|
|
int | dim ) |
◆ getSlacksReal() [2/2]
gets the vector of slack values if available; returns true on success
◆ getStarterName()
◆ getUpperReal()
◆ hasBasis()
is an advanced starting basis available?
◆ hasDual()
◆ hasDualFarkas()
bool hasDualFarkas |
( |
| ) |
const |
is Farkas proof of infeasibility available?
◆ hasPrimal()
◆ hasPrimalRay()
bool hasPrimalRay |
( |
| ) |
const |
is a primal unbounded ray available?
◆ hasSol()
◆ ignoreUnscaledViolations()
bool ignoreUnscaledViolations |
( |
| ) |
|
◆ intParam()
returns integer parameter value
◆ isDualFeasible()
bool isDualFeasible |
( |
| ) |
const |
is stored dual solution feasible?
◆ isPrimalFeasible()
bool isPrimalFeasible |
( |
| ) |
const |
is stored primal solution feasible?
◆ lhsRational() [1/2]
returns left-hand side vector
◆ lhsRational() [2/2]
returns left-hand side of row i
◆ lhsReal()
returns left-hand side of row i
◆ lhsRealInternal()
returns left-hand side vector, ignoring scaling
◆ loadSettingsFile()
reads settings file; returns true on success
◆ lowerRational() [1/2]
returns lower bound vector
◆ lowerRational() [2/2]
returns lower bound of column i
◆ lowerReal()
R lowerReal |
( |
int | i | ) |
const |
returns lower bound of column i
◆ lowerRealInternal()
returns lower bound vector
◆ maxAbsNonzeroRational()
Rational maxAbsNonzeroRational |
( |
| ) |
const |
returns biggest non-zero element in absolute value
◆ maxAbsNonzeroReal()
R maxAbsNonzeroReal |
( |
| ) |
const |
returns biggest non-zero element in absolute value
◆ maxObjRational() [1/2]
returns objective function vector after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
◆ maxObjRational() [2/2]
returns objective value of column i after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
◆ maxObjReal()
R maxObjReal |
( |
int | i | ) |
const |
returns objective value of column i after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
◆ maxObjRealInternal()
returns objective function vector after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
◆ minAbsNonzeroRational()
Rational minAbsNonzeroRational |
( |
| ) |
const |
returns smallest non-zero element in absolute value
◆ minAbsNonzeroReal()
R minAbsNonzeroReal |
( |
| ) |
const |
returns smallest non-zero element in absolute value
◆ multBasis()
multiply with basis matrix; B * vec (inplace)
- Parameters
-
vec | (dense) vector to be multiplied with |
unscale | determines whether the result should be unscaled according to the original LP data |
◆ multBasisTranspose()
multiply with transpose of basis matrix; vec * B^T (inplace)
- Parameters
-
vec | (dense) vector to be multiplied with |
unscale | determines whether the result should be unscaled according to the original LP data |
◆ numCols()
Templated function that returns number of columns.
◆ numColsRational()
int numColsRational |
( |
| ) |
const |
◆ numColsReal()
int numColsReal |
( |
| ) |
const |
◆ numIterations()
int numIterations |
( |
| ) |
const |
number of iterations since last call to solve
◆ numNonzeros()
int numNonzeros |
( |
| ) |
const |
returns number of nonzeros
◆ numNonzerosRational()
int numNonzerosRational |
( |
| ) |
const |
◆ numRows()
◆ numRowsRational()
int numRowsRational |
( |
| ) |
const |
◆ numRowsReal()
int numRowsReal |
( |
| ) |
const |
◆ objRational()
returns objective value of column i
◆ objReal()
returns objective value of column i
◆ objValueRational()
returns the objective value if a primal solution is available
◆ objValueReal()
returns the objective value if a primal solution is available
◆ operator=()
◆ optimize()
◆ parseSettingsString()
parses one setting string and returns true on success; note that string is modified
◆ printDecompDisplayLine()
prints a display line of the flying table for the DBDS
◆ printOriginalProblemStatistics()
void printOriginalProblemStatistics |
( |
std::ostream & | os | ) |
|
|
private |
stores the problem statistics of the original problem
◆ printShortStatistics()
void printShortStatistics |
( |
std::ostream & | os | ) |
|
◆ printSolutionStatistics()
void printSolutionStatistics |
( |
std::ostream & | os | ) |
|
prints solution statistics
◆ printSolvingStatistics()
void printSolvingStatistics |
( |
std::ostream & | os | ) |
|
prints statistics on solving process
◆ printStatistics()
void printStatistics |
( |
std::ostream & | os | ) |
|
prints complete statistics
◆ printStatus()
◆ printUserSettings()
void printUserSettings |
( |
| ) |
|
print non-default parameter values
◆ printVersion()
void printVersion |
( |
| ) |
const |
prints version and compilation options
◆ randomSeed()
returns the current random seed of the solver instance
◆ readBasisFile()
reads basis information from filename and returns true on success; if rowNames and colNames are NULL , default names are assumed; returns true on success
◆ readFile()
reads LP file in LP or MPS format according to READMODE parameter; gets row names, column names, and integer variables if desired; returns true on success
◆ realParam()
returns real parameter value
◆ removeColRangeRational()
void removeColRangeRational |
( |
int | start, |
|
|
int | end, |
|
|
int | perm[] = 0 ) |
removes columns start to end including both; an array perm of size numColsRational() may be passed as buffer memory
◆ removeColRangeReal()
removes columns start to end including both; an array perm of size numColsReal() may be passed as buffer memory
◆ removeColRational()
◆ removeColReal()
◆ removeColsRational() [1/2]
remove all columns with indices in array idx of size n ; an array perm of size numColsRational() may be passed as buffer memory
◆ removeColsRational() [2/2]
void removeColsRational |
( |
int | perm[] | ) |
|
removes all columns with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where column i has been moved to; note that perm must point to an array of size at least numColsRational()
◆ removeColsReal() [1/2]
remove all columns with indices in array idx of size n ; an array perm of size numColsReal() may be passed as buffer memory
◆ removeColsReal() [2/2]
removes all columns with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where column i has been moved to; note that perm must point to an array of size at least numColsReal()
◆ removeRowRangeRational()
void removeRowRangeRational |
( |
int | start, |
|
|
int | end, |
|
|
int | perm[] = 0 ) |
removes rows start to end including both; an array perm of size numRowsRational() may be passed as buffer memory
◆ removeRowRangeReal()
removes rows start to end including both; an array perm of size numRows() may be passed as buffer memory
◆ removeRowRational()
◆ removeRowReal()
◆ removeRowsRational() [1/2]
remove all rows with indices in array idx of size n ; an array perm of size numRowsRational() may be passed as buffer memory
◆ removeRowsRational() [2/2]
void removeRowsRational |
( |
int | perm[] | ) |
|
removes all rows with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where row i has been moved to; note that perm must point to an array of size at least numRowsRational()
◆ removeRowsReal() [1/2]
remove all rows with indices in array idx of size n ; an array perm of size numRows() may be passed as buffer memory
◆ removeRowsReal() [2/2]
removes all rows with an index i such that perm [i] < 0; upon completion, perm [i] >= 0 indicates the new index where row i has been moved to; note that perm must point to an array of size at least numRows()
◆ resetSettings()
resets default parameter settings
◆ rhsRational() [1/2]
returns right-hand side vector
◆ rhsRational() [2/2]
returns right-hand side of row i
◆ rhsReal()
returns right-hand side of row i
◆ rhsRealInternal()
returns right-hand side vector, ignoring scaling
◆ rowTypeRational()
returns inequality type of row i
◆ rowTypeReal()
returns inequality type of row i
◆ rowVectorRational()
◆ rowVectorRealInternal()
returns vector of row i , ignoring scaling
◆ saveSettingsFile()
writes settings file; returns true on success
◆ setBasis()
sets starting basis via arrays of statuses
◆ setBoolParam()
sets boolean parameter value; returns true on success
◆ setDualNorms()
bool setDualNorms |
( |
int | nnormsRow, |
|
|
int | nnormsCol, |
|
|
R * | norms ) |
sets steepest edge norms and returns false if that's not possible
◆ setIntegralityInformation()
void setIntegralityInformation |
( |
int | ncols, |
|
|
int * | intInfo ) |
pass integrality information about the variables to the solver
◆ setIntParam()
sets integer parameter value; returns true on success
◆ setRandomSeed()
set the random seeds of the solver instance
◆ setRealParam()
sets real parameter value; returns true on success
◆ setSettings()
sets parameter settings; returns true on success
◆ setTimings()
set statistic timers to a certain type
◆ settings()
returns current parameter settings
◆ solve()
◆ solveTime()
time spent in last call to solve
◆ statisticString()
std::string statisticString |
( |
| ) |
const |
statistical information in form of a string
◆ status()
returns the current solver status
◆ syncLPRational()
synchronizes rational LP with real LP, i.e., copies real LP to rational LP, if sync mode is manual
◆ syncLPReal()
synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, if sync mode is manual
◆ totalSizeDualRational()
get size of dual solution
◆ totalSizePrimalRational()
get size of primal solution
◆ upperRational() [1/2]
returns upper bound vector
◆ upperRational() [2/2]
returns upper bound of column i
◆ upperReal()
R upperReal |
( |
int | i | ) |
const |
returns upper bound of column i
◆ upperRealInternal()
returns upper bound vector
◆ writeBasisFile()
writes basis information to filename ; if rowNames and colNames are NULL , default names are used; returns true on success
◆ writeDualFileReal()
writes the dual of the real LP to file; LP or MPS format is chosen from the extension in filename ; if rowNames and colNames are NULL , default names are used; if intVars is not NULL , the variables contained in it are marked as integer; returns true on success
◆ writeFile()
Templated write function Real writes real LP to file; LP or MPS format is chosen from the extension in filename ; if rowNames and colNames are NULL , default names are used; if intVars is not NULL , the variables contained in it are marked as integer; returns true on success Rational writes rational LP to file; LP or MPS format is chosen from the extension in filename ; if rowNames and colNames are NULL , default names are used; if intVars is not NULL , the variables contained in it are marked as integer; returns true on success.
◆ writeFileRational()
◆ writeFileReal()
◆ writeStateRational()
writes internal LP, basis information, and parameter settings; if rowNames and colNames are NULL , default names are used
◆ writeStateReal()
writes internal LP, basis information, and parameter settings; if rowNames and colNames are NULL , default names are used
◆ _applyPolishing
◆ _basisStatusCols
◆ _basisStatusRows
◆ _beforeLiftCols
◆ _beforeLiftRows
◆ _colNames
◆ _colTypes
◆ _compSlackColId
◆ _compSlackDualRowId
◆ _compSlufactor
◆ _compSolver
◆ _currentProb
◆ _currentSettings
◆ _decompColStatus
◆ _decompCompPrimalColIDs
◆ _decompCompPrimalFixedVarIDs
◆ _decompCompPrimalRowIDs
◆ _decompCompPrimalVarBoundIDs
◆ _decompCompProbColIDsIdx
int* _decompCompProbColIDsIdx |
|
private |
◆ _decompDisplayLine
◆ _decompDualColIDs
◆ _decompDualRowIDs
◆ _decompElimPrimalRowIDs
◆ _decompFeasVector
◆ _decompFixedVarDualIDs
◆ _decompLP
◆ _decompPrimalColIDs
◆ _decompPrimalRowIDs
◆ _decompReducedProbColIDs
◆ _decompReducedProbColRowIDs
◆ _decompReducedProbCols
bool* _decompReducedProbCols |
|
private |
◆ _decompReducedProbRowIDs
◆ _decompReducedProbRows
bool* _decompReducedProbRows |
|
private |
◆ _decompRowStatus
◆ _decompTransBasis
◆ _decompVarBoundDualIDs
◆ _decompViolatedBounds
int* _decompViolatedBounds |
|
private |
◆ _decompViolatedRows
◆ _feasLhs
◆ _feasLower
◆ _feasObj
◆ _feasRhs
◆ _feasUpper
◆ _fixedOrigVars
◆ _hasBasis
◆ _hasSolRational
◆ _hasSolReal
◆ _isRealLPLoaded
◆ _isRealLPScaled
◆ _lastSolveMode
◆ _manualLhs
◆ _manualLower
◆ _manualObj
◆ _manualRealLP
◆ _manualRhs
◆ _manualUpper
◆ _modLhs
◆ _modLower
◆ _modObj
◆ _modRhs
◆ _modUpper
◆ _nCompPrimalCols
◆ _nCompPrimalRows
◆ _nDecompViolBounds
◆ _nDecompViolRows
◆ _nDualCols
◆ _nDualRows
◆ _nElimPrimalRows
◆ _nPrimalCols
◆ _nPrimalRows
◆ _optimizeCalls
◆ _pricerAuto
◆ _pricerDantzig
◆ _pricerDevex
◆ _pricerParMult
◆ _pricerQuickSteep
◆ _pricerSteep
◆ _primalDualDiff
◆ _rationalFeastol
◆ _rationalLP
◆ _rationalLUSolver
◆ _rationalLUSolverBind
◆ _rationalMaxscaleincr
◆ _rationalNegInfty
◆ _rationalNegone
◆ _rationalOpttol
◆ _rationalPosInfty
◆ _rationalPosone
◆ _rationalZero
◆ _ratiotesterBoundFlipping
◆ _ratiotesterFast
◆ _ratiotesterHarris
◆ _ratiotesterTextbook
◆ _realLP
◆ _rowNames
◆ _rowTypes
◆ _scaler
◆ _scalerBiequi
◆ _scalerGeo1
◆ _scalerGeo8
◆ _scalerGeoequi
◆ _scalerLeastsq
◆ _scalerUniequi
◆ _simplifier
◆ _simplifierMainSM
◆ _simplifierPaPILO
◆ _slackCols
◆ _slufactor
◆ _solRational
◆ _solReal
◆ _solver
◆ _starter
◆ _starterSum
◆ _starterVector
◆ _starterWeight
◆ _statistics
statistics since last call to solveReal() or solveRational()
Definition at line 1638 of file soplex.h.
◆ _status
◆ _storedBasis
◆ _storedBasisStatusCols
◆ _storedBasisStatusRows
◆ _tauColVector
◆ _transformedObj
◆ _transformedRows
◆ _unboundedLhs
◆ _unboundedLower
◆ _unboundedRhs
◆ _unboundedUpper
◆ _unitMatrixRational
◆ _unscaleCalls
◆ _workSol
◆ maxAbsNonzero
◆ minAbsNonzero
◆ nNonzeros
◆ numCompProbIter
◆ numDecompIter
◆ numIncludedRows
◆ numProbCols
◆ numProbRows
◆ numRedProbIter
◆ origCountBoxed
◆ origCountEqual
◆ origCountFreeCol
◆ origCountFreeRow
◆ origCountLhs
◆ origCountLower
◆ origCountRanged
◆ origCountRhs
◆ origCountUpper
◆ spxout
|