|
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[]=nullptr) |
| 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[]=nullptr) |
| 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[]=nullptr) |
| 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[]=nullptr) |
| 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[]=nullptr) |
| 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[]=nullptr) |
| 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[]=nullptr) |
| 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[]=nullptr) |
| 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=nullptr) |
| optimize the given LP
|
|
SPxSolverBase< R >::Status | solve (volatile bool *interrupt=nullptr) |
|
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=nullptr, int *ninds=nullptr, bool unscale=true) |
| computes row r of basis inverse; returns true on success
|
|
bool | getBasisInverseColReal (int c, R *coef, int *inds=nullptr, int *ninds=nullptr, 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
|
|
int | numRefinements () const |
| number of iterative refinements
|
|
int | numPrecisionBoosts () const |
| number of precision boosts since last call to solve
|
|
int | numIterationsBoosted () const |
| number of iterations in higher precision since last call to solve
|
|
Real | precisionBoostTime () const |
| time spen in higher precision 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=nullptr, NameSet *colNames=nullptr, DIdxSet *intVars=nullptr) |
| 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=nullptr, const NameSet *colNames=nullptr, const DIdxSet *intvars=nullptr, const bool unscale=true, const bool writeZeroObjective=false) 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 nullptr , default names are used; if intVars is not nullptr , 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 nullptr , default names are used; if intVars is not nullptr , the variables contained in it are marked as integer; returns true on success.
|
|
bool | writeFileRational (const char *filename, const NameSet *rowNames=nullptr, const NameSet *colNames=nullptr, const DIdxSet *intvars=nullptr, const bool writeZeroObjective=false) const |
|
bool | writeFileReal (const char *filename, const NameSet *rowNames=nullptr, const NameSet *colNames=nullptr, const DIdxSet *intvars=nullptr, const bool unscale=true, const bool writeZeroObjective=false) const |
|
bool | writeDualFileReal (const char *filename, const NameSet *rowNames=nullptr, const NameSet *colNames=nullptr, const DIdxSet *intvars=nullptr, const bool writeZeroObjective=false) 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 nullptr , default names are used; if intVars is not nullptr , the variables contained in it are marked as integer; returns true on success
|
|
bool | readBasisFile (const char *filename, const NameSet *rowNames=nullptr, const NameSet *colNames=nullptr) |
| reads basis information from filename and returns true on success; if rowNames and colNames are nullptr , default names are assumed; returns true on success
|
|
bool | writeBasisFile (const char *filename, const NameSet *rowNames=nullptr, const NameSet *colNames=nullptr, const bool cpxFormat=false) const |
| writes basis information to filename ; if rowNames and colNames are nullptr , default names are used; returns true on success
|
|
void | writeStateReal (const char *filename, const NameSet *rowNames=nullptr, const NameSet *colNames=nullptr, const bool cpxFormat=false, const bool writeZeroObjective=false) const |
| writes internal LP, basis information, and parameter settings; if rowNames and colNames are nullptr , default names are used
|
|
void | writeStateRational (const char *filename, const NameSet *rowNames=nullptr, const NameSet *colNames=nullptr, const bool cpxFormat=false, const bool writeZeroObjective=false) const |
| writes internal LP, basis information, and parameter settings; if rowNames and colNames are nullptr , 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 | _isBoostedConsistent () const |
| checks consistency for the boosted solver
|
|
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 | _solveBoostedRealLPAndRecordStatistics (volatile bool *interrupt=nullptr) |
| call floating-point solver and update statistics on iterations etc.
|
|
void | _solveRealLPAndRecordStatistics (volatile bool *interrupt=nullptr) |
| call floating-point solver and update statistics on iterations etc.
|
|
bool | _readFileReal (const char *filename, NameSet *rowNames=nullptr, NameSet *colNames=nullptr, DIdxSet *intVars=nullptr) |
| 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=nullptr, NameSet *colNames=nullptr, DIdxSet *intVars=nullptr) |
| 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
|
|
|
template<typename T > |
void | _storeRealSolutionAsRational (SolRational &sol, VectorBase< T > &primalReal, VectorBase< T > &dualReal, int &dualSize) |
| stores floating-point solution of original LP as current rational solution and ensure that solution vectors have right dimension; ensure that solution is aligned with basis
|
|
void | _computeBoundsViolation (SolRational &sol, Rational &boundsViolation) |
| computes violation of bounds during the refinement loop
|
|
void | _computeSidesViolation (SolRational &sol, Rational &sideViolation) |
| computes violation of sides during the refinement loop
|
|
void | _computeReducedCostViolation (SolRational &sol, Rational &redCostViolation, const bool &maximizing) |
| computes violation of reduced costs during the refinement loop
|
|
void | _computeDualViolation (SolRational &sol, Rational &dualViolation, const bool &maximizing) |
| computes dual violation during the refinement loop
|
|
bool | _isRefinementOver (bool &primalFeasible, bool &dualFeasible, Rational &boundsViolation, Rational &sideViolation, Rational &redCostViolation, Rational &dualViolation, int minIRRoundsRemaining, bool &stoppedTime, bool &stoppedIter, int numFailedRefinements) |
| checks termination criteria for refinement loop
|
|
void | _checkRefinementProgress (Rational &boundsViolation, Rational &sideViolation, Rational &redCostViolation, Rational &dualViolation, Rational &maxViolation, Rational &bestViolation, const Rational &violationImprovementFactor, int &numFailedRefinements) |
| checks refinement loop progress
|
|
void | _ratrecAndOrRatfac (int &minIRRoundsRemaining, int &lastStallIterations, int &numberOfIterations, bool &factorSolNewBasis, int &nextRatrec, const Rational &errorCorrectionFactor, Rational &errorCorrection, Rational &maxViolation, SolRational &sol, bool &primalFeasible, bool &dualFeasible, bool &stoppedTime, bool &stoppedIter, bool &error, bool &breakAfter, bool &continueAfter) |
| performs rational reconstruction and/or factorizationd
|
|
void | _forceNonbasicToBound (SolRational &sol, int &c, const int &maxDimRational, bool toLower) |
| forces value of given nonbasic variable to bound
|
|
void | _computePrimalScalingFactor (Rational &maxScale, Rational &primalScale, Rational &boundsViolation, Rational &sideViolation, Rational &redCostViolation) |
| computes primal scaling factor; limit increase in scaling by tolerance used in floating point solve
|
|
void | _computeDualScalingFactor (Rational &maxScale, Rational &primalScale, Rational &dualScale, Rational &redCostViolation, Rational &dualViolation) |
| computes dual scaling factor; limit increase in scaling by tolerance used in floating point solve
|
|
template<typename T > |
void | _applyScaledBounds (SPxSolverBase< T > &solver, Rational &primalScale) |
| applies scaled bounds
|
|
template<typename T > |
void | _applyScaledSides (SPxSolverBase< T > &solver, Rational &primalScale) |
| applies scaled sides
|
|
template<typename T > |
void | _applyScaledObj (SPxSolverBase< T > &solver, Rational &dualScale, SolRational &sol) |
| applies scaled objective function
|
|
template<typename T > |
bool | _evaluateResult (SPxSolverBase< T > &solver, typename SPxSolverBase< T >::Status result, bool usingRefinedLP, SolRational &sol, VectorBase< T > &dualReal, bool &infeasible, bool &unbounded, bool &stoppedTime, bool &stoppedIter, bool &error) |
| evaluates result of solve. Return true if the algorithm must to stopped, false otherwise.
|
|
template<typename T > |
void | _correctPrimalSolution (SolRational &sol, Rational &primalScale, int &primalSize, const int &maxDimRational, VectorBase< T > &primalReal) |
| corrects primal solution and aligns with basis
|
|
void | _updateSlacks (SolRational &sol, int &primalSize) |
| updates or recomputes slacks depending on which looks faster
|
|
template<typename T > |
void | _correctDualSolution (SPxSolverBase< T > &solver, SolRational &sol, const bool &maximizing, VectorBase< T > &dualReal, Rational &dualScale, int &dualSize, const int &maxDimRational) |
| corrects dual solution and aligns with basis
|
|
void | _updateReducedCosts (SolRational &sol, int &dualSize, const int &numCorrectedPrimals) |
| updates or recomputes reduced cost values depending on which looks faster; adding one to the length of the dual vector accounts for the objective function vector
|
|
void | _convertDataArrayVarStatusToBoosted (DataArray< typename SPxSolverBase< R >::VarStatus > &base, DataArray< typename SPxSolverBase< BP >::VarStatus > ©) |
|
void | _convertDataArrayVarStatusToRPrecision (DataArray< typename SPxSolverBase< BP >::VarStatus > &base, DataArray< typename SPxSolverBase< R >::VarStatus > ©) |
|
void | _switchToBoosted () |
| disable initial precision solver and switch to boosted solver
|
|
void | _setupBoostedSolver () |
| setup boosted solver before launching iteration
|
|
bool | _boostPrecision () |
| increase the multiprecision, return false if maximum precision is reached, true otherwise
|
|
void | _resetBoostedPrecision () |
| reset the boosted precision to the default value
|
|
bool | _setupBoostedSolverAfterRecovery () |
| setup recovery mecanism using multiprecision, return false if maximum precision reached, true otherwise
|
|
bool | _isBoostedStartingFromSlack (bool initialSolve=true) |
| return true if slack basis has to be loaded for boosted solver
|
|
void | _switchToStandardMode () |
| indicate if we are testing feasibility, unboundedness or neither
|
|
void | _switchToFeasMode () |
|
void | _switchToUnbdMode () |
|
bool | _inStandardMode () |
| check if we are testing feasibility, unboundedness or neither
|
|
bool | _inFeasMode () |
|
bool | _inUnbdMode () |
|
void | _storeBasisAsOldBasis (DataArray< typename SPxSolverBase< R >::VarStatus > &rows, DataArray< typename SPxSolverBase< R >::VarStatus > &cols) |
|
void | _storeBasisAsOldBasisBoosted (DataArray< typename SPxSolverBase< BP >::VarStatus > &rows, DataArray< typename SPxSolverBase< BP >::VarStatus > &cols) |
|
void | _storeLastStableBasis (bool vanished) |
|
void | _storeLastStableBasisBoosted (bool vanished) |
|
bool | _loadBasisFromOldBasis (bool boosted) |
|
void | _updateBoostingStatistics () |
|
void | _solveRealForRationalBoostedStable (SolRational &sol, bool &primalFeasible, bool &dualFeasible, bool &infeasible, bool &unbounded, bool &stoppedTime, bool &stoppedIter, bool &error, bool &needNewBoostedIt) |
| solves current problem using multiprecision floating-point solver return false if a new boosted iteration is necessary, true otherwise
|
|
void | _performOptIRStableBoosted (SolRational &sol, bool acceptUnbounded, bool acceptInfeasible, int minIRRoundsRemaining, bool &primalFeasible, bool &dualFeasible, bool &infeasible, bool &unbounded, bool &stoppedTime, bool &stoppedIter, bool &error, bool &needNewBoostedIt) |
| solves current problem with iterative refinement and recovery mechanism using boosted solver
|
|
void | _performOptIRWrapper (SolRational &sol, bool acceptUnbounded, bool acceptInfeasible, int minIRRoundsRemaining, bool &primalFeasible, bool &dualFeasible, bool &infeasible, bool &unbounded, bool &stoppedTime, bool &stoppedIter, bool &error) |
| perform iterative refinement using the right precision
|
|
void | _solveRealForRationalStable (SolRational &sol, bool &primalFeasible, bool &dualFeasible, bool &infeasible, bool &unbounded, bool &stoppedTime, bool &stoppedIter, bool &error) |
| solves current problem using double floating-point solver
|
|
void | _performOptIRStable (SolRational &sol, bool acceptUnbounded, bool acceptInfeasible, int minIRRoundsRemaining, 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 | _solveRealForRationalBoosted (VectorBase< BP > &primal, VectorBase< BP > &dual, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusRows, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusCols, typename SPxSolverBase< BP >::Status &boostedResult, bool initialSolve) |
| solves real LP during iterative refinement
|
|
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=nullptr) |
| solves the templated LP
|
|
void | _optimizeRational (volatile bool *interrupt=nullptr) |
| 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=nullptr) |
| 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 | _verifyObjLimitReal () |
| verify computed obj stop 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
|
|
bool | checkBasisDualFeasibility (VectorBase< R > feasVec) |
| checks the dual feasibility of the current basis
|
|
|
enum | BoolParam {
LIFTING = 0
, EQTRANS = 1
, TESTDUALINF = 2
, RATFAC = 3
,
ACCEPTCYCLING = 4
, RATREC = 5
, POWERSCALING = 6
, RATFACJUMP = 7
,
ROWBOUNDFLIPS = 8
, PERSISTENTSCALING = 9
, FULLPERTURBATION = 10
, ENSURERAY = 11
,
FORCEBASIC = 12
, SIMPLIFIER_SINGLETONCOLS = 13
, SIMPLIFIER_CONSTRAINTPROPAGATION = 14
, SIMPLIFIER_PARALLELROWDETECTION = 15
,
SIMPLIFIER_PARALLELCOLDETECTION = 16
, SIMPLIFIER_SINGLETONSTUFFING = 17
, SIMPLIFIER_DUALFIX = 18
, SIMPLIFIER_FIXCONTINUOUS = 19
,
SIMPLIFIER_DOMINATEDCOLS = 20
, ITERATIVE_REFINEMENT = 21
, ADAPT_TOLS_TO_MULTIPRECISION = 22
, PRECISION_BOOSTING = 23
,
BOOSTED_WARM_START = 24
, RECOVERY_MECHANISM = 25
, BOOLPARAM_COUNT = 26
} |
| 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
,
PRINTBASISMETRIC = 24
, STATTIMER = 25
, MULTIPRECISION_LIMIT = 26
, STORE_BASIS_SIMPLEX_FREQ = 27
,
INTPARAM_COUNT = 28
} |
| 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
, PRECISION_BOOSTING_FACTOR = 26
, REALPARAM_COUNT = 27
} |
| 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
|
|
const std::shared_ptr< Tolerances > | tolerances () const |
| returns current tolerances
|
|
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.
◆ BP
◆ 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 1285 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 1350 of file soplex.h.
◆ anonymous enum
values for parameter READMODE
Enumerator |
---|
READMODE_REAL | standard floating-point parsing
|
READMODE_RATIONAL | rational parsing
|
Definition at line 1314 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 1206 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 1174 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 1263 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 1247 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 1376 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 1222 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 1324 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 1164 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 1301 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 1363 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 1184 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 1151 of file soplex.h.
◆ anonymous enum
values for parameter OBJSENSE
Enumerator |
---|
OBJSENSE_MINIMIZE | minimization
|
OBJSENSE_MAXIMIZE | maximization
|
Definition at line 1141 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 1337 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?
|
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 solution
|
SIMPLIFIER_SINGLETONCOLS | |
SIMPLIFIER_CONSTRAINTPROPAGATION | |
SIMPLIFIER_PARALLELROWDETECTION | |
SIMPLIFIER_PARALLELCOLDETECTION | |
SIMPLIFIER_SINGLETONSTUFFING | |
SIMPLIFIER_DUALFIX | |
SIMPLIFIER_FIXCONTINUOUS | |
SIMPLIFIER_DOMINATEDCOLS | |
ITERATIVE_REFINEMENT | |
ADAPT_TOLS_TO_MULTIPRECISION | adapt tolerances to the multiprecision used
|
PRECISION_BOOSTING | enable precision boosting ?
|
BOOSTED_WARM_START | boosted solver start from last basis
|
RECOVERY_MECHANISM | try different settings when solve fails
|
BOOLPARAM_COUNT | number of boolean parameters
|
Definition at line 964 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
|
PRINTBASISMETRIC | print condition number during the solve
|
STATTIMER | type of timer for statistics
|
MULTIPRECISION_LIMIT | |
STORE_BASIS_SIMPLEX_FREQ | - Todo
- precision-boosting find better parameter name after how many simplex pivots do we store the advanced and stable basis, 1 = every iterations
|
INTPARAM_COUNT | number of integer parameters
|
Definition at line 1049 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 1869 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
|
PRECISION_BOOSTING_FACTOR | factor by which the precision of the floating-point solver is multiplied
|
REALPARAM_COUNT | number of real parameters
|
Definition at line 1389 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]
template<class R >
void _addColReal |
( |
R | obj, |
|
|
R | lower, |
|
|
const SVectorBase< R > & | lpcol, |
|
|
R | upper ) |
|
private |
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]
template<class R >
void _addRowReal |
( |
const LPRowBase< R > & | lprow | ) |
|
|
private |
adds a single row to the real LP and adjusts basis
◆ _addRowReal() [2/2]
template<class R >
void _addRowReal |
( |
R | lhs, |
|
|
const SVectorBase< R > & | lprow, |
|
|
R | rhs ) |
|
private |
adds a single row to the real LP and adjusts basis
◆ _addRowsReal()
adds multiple rows to the real LP and adjusts basis
◆ _applyScaledBounds()
template<class R >
template<typename T >
◆ _applyScaledObj()
template<class R >
template<typename T >
applies scaled objective function
◆ _applyScaledSides()
template<class R >
template<typename T >
◆ _boostPrecision()
increase the multiprecision, return false if maximum precision is reached, true otherwise
◆ _changeBoundsReal() [1/2]
changes vectors of column bounds to lower and upper and adjusts basis
◆ _changeBoundsReal() [2/2]
template<class R >
void _changeBoundsReal |
( |
int | i, |
|
|
const R & | lower, |
|
|
const R & | upper ) |
|
private |
changes bounds of column i to lower and upper and adjusts basis
◆ _changeColReal()
template<class R >
void _changeColReal |
( |
int | i, |
|
|
const LPColReal & | lpcol ) |
|
private |
replaces column i with lpcol and adjusts basis
◆ _changeElementReal()
template<class R >
void _changeElementReal |
( |
int | i, |
|
|
int | j, |
|
|
const R & | val ) |
|
private |
changes matrix entry in row i and column j to val and adjusts basis
◆ _changeLhsReal() [1/2]
template<class R >
void _changeLhsReal |
( |
const VectorBase< R > & | lhs | ) |
|
|
private |
changes left-hand side vector for constraints to lhs and adjusts basis
◆ _changeLhsReal() [2/2]
template<class R >
void _changeLhsReal |
( |
int | i, |
|
|
const R & | lhs ) |
|
private |
changes left-hand side of row i to lhs and adjusts basis
◆ _changeLowerReal() [1/2]
template<class R >
void _changeLowerReal |
( |
const VectorBase< R > & | lower | ) |
|
|
private |
changes vector of lower bounds to lower and adjusts basis
◆ _changeLowerReal() [2/2]
template<class R >
void _changeLowerReal |
( |
int | i, |
|
|
const R & | lower ) |
|
private |
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]
template<class R >
void _changeRangeReal |
( |
int | i, |
|
|
const R & | lhs, |
|
|
const R & | rhs ) |
|
private |
changes left- and right-hand side of row i and adjusts basis
◆ _changeRhsReal() [1/2]
template<class R >
void _changeRhsReal |
( |
const VectorBase< R > & | rhs | ) |
|
|
private |
changes right-hand side vector to rhs and adjusts basis
◆ _changeRhsReal() [2/2]
template<class R >
void _changeRhsReal |
( |
int | i, |
|
|
const R & | rhs ) |
|
private |
changes right-hand side of row i to rhs and adjusts basis
◆ _changeRowReal()
template<class R >
void _changeRowReal |
( |
int | i, |
|
|
const LPRowBase< R > & | lprow ) |
|
private |
replaces row i with lprow and adjusts basis
◆ _changeUpperReal() [1/2]
template<class R >
void _changeUpperReal |
( |
const VectorBase< R > & | upper | ) |
|
|
private |
changes vector of upper bounds to upper and adjusts basis
◆ _changeUpperReal() [2/2]
template<class R >
void _changeUpperReal |
( |
int | i, |
|
|
const R & | upper ) |
|
private |
changes i 'th upper bound to upper and adjusts basis
◆ _checkBasisScaling()
template<class R >
void _checkBasisScaling |
( |
| ) |
|
|
private |
check correctness of (un)scaled basis matrix operations
◆ _checkRefinementProgress()
checks refinement loop progress
◆ _checkScaling()
template<class R >
void _checkScaling |
( |
SPxLPBase< R > * | origLP | ) |
const |
|
private |
◆ _completeRangeTypesRational()
template<class R >
void _completeRangeTypesRational |
( |
| ) |
|
|
private |
completes range type arrays after adding columns and/or rows
◆ _computeBasisInverseRational()
template<class R >
void _computeBasisInverseRational |
( |
| ) |
|
|
private |
computes rational inverse of basis matrix as defined by _rationalLUSolverBind
◆ _computeBoundsViolation()
computes violation of bounds during the refinement loop
◆ _computeDualScalingFactor()
computes dual scaling factor; limit increase in scaling by tolerance used in floating point solve
◆ _computeDualViolation()
template<class R >
void _computeDualViolation |
( |
SolRational & | sol, |
|
|
Rational & | dualViolation, |
|
|
const bool & | maximizing ) |
|
private |
computes dual violation during the refinement loop
◆ _computeInfeasBox()
template<class R >
void _computeInfeasBox |
( |
SolRational & | sol, |
|
|
bool | transformed ) |
|
private |
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().
◆ _computePrimalScalingFactor()
computes primal scaling factor; limit increase in scaling by tolerance used in floating point solve
◆ _computeReducedCostViolation()
template<class R >
void _computeReducedCostViolation |
( |
SolRational & | sol, |
|
|
Rational & | redCostViolation, |
|
|
const bool & | maximizing ) |
|
private |
computes violation of reduced costs during the refinement loop
◆ _computeSidesViolation()
computes violation of sides during the refinement loop
◆ _convertDataArrayVarStatusToBoosted()
- Todo
- precision-boosting move some place else converts the given DataArray of VarStatus to boostedPrecision
◆ _convertDataArrayVarStatusToRPrecision()
- Todo
- precision-boosting move some place else converts the given DataArray of VarStatus to R precision
◆ _correctDualSolution()
template<class R >
template<typename T >
corrects dual solution and aligns with basis
◆ _correctPrimalSolution()
template<class R >
template<typename T >
void _correctPrimalSolution |
( |
SolRational & | sol, |
|
|
Rational & | primalScale, |
|
|
int & | primalSize, |
|
|
const int & | maxDimRational, |
|
|
VectorBase< T > & | primalReal ) |
|
private |
corrects primal solution and aligns with basis
◆ _disableSimplifierAndScaler()
template<class R >
void _disableSimplifierAndScaler |
( |
| ) |
|
|
private |
disables simplifier and scaler
◆ _enableSimplifierAndScaler()
template<class R >
void _enableSimplifierAndScaler |
( |
| ) |
|
|
private |
enables simplifier and scaler according to current parameters
◆ _ensureDSVectorRationalMemory()
template<class R >
void _ensureDSVectorRationalMemory |
( |
DSVectorRational & | vec, |
|
|
const int | newmax ) const |
|
private |
extends sparse vector to hold newmax entries if and only if it holds no more free entries
◆ _ensureRationalLP()
template<class R >
void _ensureRationalLP |
( |
| ) |
|
|
private |
ensures that the rational LP is available; performs no sync
◆ _ensureRealLPLoaded()
template<class R >
void _ensureRealLPLoaded |
( |
| ) |
|
|
private |
ensures that the real LP and the basis are loaded in the solver; performs no sync
◆ _evaluateResult()
template<class R >
template<typename T >
bool _evaluateResult |
( |
SPxSolverBase< T > & | solver, |
|
|
typename SPxSolverBase< T >::Status | result, |
|
|
bool | usingRefinedLP, |
|
|
SolRational & | sol, |
|
|
VectorBase< T > & | dualReal, |
|
|
bool & | infeasible, |
|
|
bool & | unbounded, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
evaluates result of solve. Return true if the algorithm must to stopped, false otherwise.
◆ _evaluateSolutionReal()
template<class R >
void _evaluateSolutionReal |
( |
typename SPxSimplifier< R >::Result | simplificationStatus | ) |
|
|
private |
checks result of the solving process and solves again without preprocessing if necessary
◆ _factorizeColumnRational()
factorizes rational basis matrix in column representation
◆ _forceNonbasicToBound()
template<class R >
void _forceNonbasicToBound |
( |
SolRational & | sol, |
|
|
int & | c, |
|
|
const int & | maxDimRational, |
|
|
bool | toLower ) |
|
private |
forces value of given nonbasic variable to bound
◆ _idxToPerm()
template<class R >
void _idxToPerm |
( |
int * | idx, |
|
|
int | idxSize, |
|
|
int * | perm, |
|
|
int | permSize ) const |
|
private |
creates a permutation for removing rows/columns from an array of indices
◆ _inFeasMode()
◆ _inStandardMode()
check if we are testing feasibility, unboundedness or neither
◆ _inUnbdMode()
◆ _invalidateSolution()
template<class R >
void _invalidateSolution |
( |
| ) |
|
|
private |
◆ _isBoostedConsistent()
template<class R >
bool _isBoostedConsistent |
( |
| ) |
const |
|
private |
checks consistency for the boosted solver
◆ _isBoostedStartingFromSlack()
template<class R >
bool _isBoostedStartingFromSlack |
( |
bool | initialSolve = true | ) |
|
|
private |
return true if slack basis has to be loaded for boosted solver
◆ _isConsistent()
template<class R >
bool _isConsistent |
( |
| ) |
const |
|
private |
◆ _isRefinementOver()
template<class R >
bool _isRefinementOver |
( |
bool & | primalFeasible, |
|
|
bool & | dualFeasible, |
|
|
Rational & | boundsViolation, |
|
|
Rational & | sideViolation, |
|
|
Rational & | redCostViolation, |
|
|
Rational & | dualViolation, |
|
|
int | minIRRoundsRemaining, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
int | numFailedRefinements ) |
|
private |
checks termination criteria for refinement loop
◆ _isSolveStopped()
template<class R >
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
◆ _loadBasisFromOldBasis()
template<class R >
bool _loadBasisFromOldBasis |
( |
bool | boosted | ) |
|
|
private |
◆ _loadRealLP()
template<class R >
void _loadRealLP |
( |
bool | initBasis | ) |
|
|
private |
load original LP and possibly setup a slack basis
◆ _lowerFinite()
template<class R >
bool _lowerFinite |
( |
const RangeType & | rangeType | ) |
const |
|
private |
checks whether RangeType corresponds to finite lower bound
◆ _optimize()
template<class R >
void _optimize |
( |
volatile bool * | interrupt = nullptr | ) |
|
|
private |
◆ _optimizeRational()
template<class R >
void _optimizeRational |
( |
volatile bool * | interrupt = nullptr | ) |
|
|
private |
◆ _parseSettingsLine()
template<class R >
bool _parseSettingsLine |
( |
char * | line, |
|
|
const int | lineNumber ) |
|
private |
parses one line in a settings file and returns true on success; note that the string is modified
◆ _performFeasIRStable()
template<class R >
void _performFeasIRStable |
( |
SolRational & | sol, |
|
|
bool & | withDualFarkas, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
performs iterative refinement on the auxiliary problem for testing feasibility
◆ _performOptIRStable()
template<class R >
void _performOptIRStable |
( |
SolRational & | sol, |
|
|
bool | acceptUnbounded, |
|
|
bool | acceptInfeasible, |
|
|
int | minIRRoundsRemaining, |
|
|
bool & | primalFeasible, |
|
|
bool & | dualFeasible, |
|
|
bool & | infeasible, |
|
|
bool & | unbounded, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
solves current problem with iterative refinement and recovery mechanism
◆ _performOptIRStableBoosted()
template<class R >
void _performOptIRStableBoosted |
( |
SolRational & | sol, |
|
|
bool | acceptUnbounded, |
|
|
bool | acceptInfeasible, |
|
|
int | minIRRoundsRemaining, |
|
|
bool & | primalFeasible, |
|
|
bool & | dualFeasible, |
|
|
bool & | infeasible, |
|
|
bool & | unbounded, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error, |
|
|
bool & | needNewBoostedIt ) |
|
private |
solves current problem with iterative refinement and recovery mechanism using boosted solver
◆ _performOptIRWrapper()
template<class R >
void _performOptIRWrapper |
( |
SolRational & | sol, |
|
|
bool | acceptUnbounded, |
|
|
bool | acceptInfeasible, |
|
|
int | minIRRoundsRemaining, |
|
|
bool & | primalFeasible, |
|
|
bool & | dualFeasible, |
|
|
bool & | infeasible, |
|
|
bool & | unbounded, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
perform iterative refinement using the right precision
◆ _performUnboundedIRStable()
template<class R >
void _performUnboundedIRStable |
( |
SolRational & | sol, |
|
|
bool & | hasUnboundedRay, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
performs iterative refinement on the auxiliary problem for testing unboundedness
◆ _preprocessAndSolveReal()
template<class R >
void _preprocessAndSolveReal |
( |
bool | applyPreprocessing, |
|
|
volatile bool * | interrupt = nullptr ) |
|
private |
solves real LP with/without preprocessing
◆ _project()
◆ _rangeToPerm()
template<class R >
void _rangeToPerm |
( |
int | start, |
|
|
int | end, |
|
|
int * | perm, |
|
|
int | permSize ) const |
|
private |
creates a permutation for removing rows/columns from a range of indices
◆ _rangeTypeRational()
determines RangeType from rational bounds
◆ _rangeTypeReal()
template<class R >
RangeType _rangeTypeReal |
( |
const R & | lower, |
|
|
const R & | upper ) const |
|
private |
determines RangeType from real bounds
◆ _ratrecAndOrRatfac()
template<class R >
void _ratrecAndOrRatfac |
( |
int & | minIRRoundsRemaining, |
|
|
int & | lastStallIterations, |
|
|
int & | numberOfIterations, |
|
|
bool & | factorSolNewBasis, |
|
|
int & | nextRatrec, |
|
|
const Rational & | errorCorrectionFactor, |
|
|
Rational & | errorCorrection, |
|
|
Rational & | maxViolation, |
|
|
SolRational & | sol, |
|
|
bool & | primalFeasible, |
|
|
bool & | dualFeasible, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error, |
|
|
bool & | breakAfter, |
|
|
bool & | continueAfter ) |
|
private |
performs rational reconstruction and/or factorizationd
◆ _readFileRational()
template<class R >
bool _readFileRational |
( |
const char * | filename, |
|
|
NameSet * | rowNames = nullptr, |
|
|
NameSet * | colNames = nullptr, |
|
|
DIdxSet * | intVars = nullptr ) |
|
private |
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()
template<class R >
bool _readFileReal |
( |
const char * | filename, |
|
|
NameSet * | rowNames = nullptr, |
|
|
NameSet * | colNames = nullptr, |
|
|
DIdxSet * | intVars = nullptr ) |
|
private |
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()
template<class R >
bool _reapplyPersistentScaling |
( |
| ) |
const |
|
private |
check whether persistent scaling is supposed to be reapplied again after unscaling
◆ _recomputeRangeTypesRational()
template<class R >
void _recomputeRangeTypesRational |
( |
| ) |
|
|
private |
recomputes range types from scratch using rational LP
◆ _recomputeRangeTypesReal()
template<class R >
void _recomputeRangeTypesReal |
( |
| ) |
|
|
private |
recomputes range types from scratch using real LP
◆ _reconstructSolutionRational()
attempts rational reconstruction of primal-dual solution
◆ _removeColRangeReal()
template<class R >
void _removeColRangeReal |
( |
int | start, |
|
|
int | end, |
|
|
int | perm[] ) |
|
private |
removes columns start to end including both; an array perm of size numColsReal() may be passed as buffer memory
◆ _removeColReal()
template<class R >
void _removeColReal |
( |
int | i | ) |
|
|
private |
◆ _removeColsReal() [1/2]
template<class R >
void _removeColsReal |
( |
int | idx[], |
|
|
int | n, |
|
|
int | perm[] ) |
|
private |
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]
template<class R >
void _removeColsReal |
( |
int | perm[] | ) |
|
|
private |
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()
◆ _removeRowRangeReal()
template<class R >
void _removeRowRangeReal |
( |
int | start, |
|
|
int | end, |
|
|
int | perm[] ) |
|
private |
removes rows start to end including both; an array perm of size numRows() may be passed as buffer memory
◆ _removeRowReal()
template<class R >
void _removeRowReal |
( |
int | i | ) |
|
|
private |
removes row i and adjusts basis
◆ _removeRowsReal() [1/2]
template<class R >
void _removeRowsReal |
( |
int | idx[], |
|
|
int | n, |
|
|
int | perm[] ) |
|
private |
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]
template<class R >
void _removeRowsReal |
( |
int | perm[] | ) |
|
|
private |
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()
◆ _resetBoostedPrecision()
template<class R >
void _resetBoostedPrecision |
( |
| ) |
|
|
private |
reset the boosted precision to the default value
◆ _resolveWithoutPreprocessing()
template<class R >
void _resolveWithoutPreprocessing |
( |
typename SPxSimplifier< R >::Result | simplificationStatus | ) |
|
|
private |
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
◆ _setupBoostedSolver()
template<class R >
void _setupBoostedSolver |
( |
| ) |
|
|
private |
setup boosted solver before launching iteration
◆ _setupBoostedSolverAfterRecovery()
template<class R >
bool _setupBoostedSolverAfterRecovery |
( |
| ) |
|
|
private |
setup recovery mecanism using multiprecision, return false if maximum precision reached, true otherwise
◆ _solveBoostedRealLPAndRecordStatistics()
template<class R >
void _solveBoostedRealLPAndRecordStatistics |
( |
volatile bool * | interrupt = nullptr | ) |
|
|
private |
call floating-point solver and update statistics on iterations etc.
◆ _solveRealForRational()
solves real LP during iterative refinement
◆ _solveRealForRationalBoosted()
solves real LP during iterative refinement
◆ _solveRealForRationalBoostedStable()
template<class R >
void _solveRealForRationalBoostedStable |
( |
SolRational & | sol, |
|
|
bool & | primalFeasible, |
|
|
bool & | dualFeasible, |
|
|
bool & | infeasible, |
|
|
bool & | unbounded, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error, |
|
|
bool & | needNewBoostedIt ) |
|
private |
solves current problem using multiprecision floating-point solver return false if a new boosted iteration is necessary, true otherwise
◆ _solveRealForRationalStable()
template<class R >
void _solveRealForRationalStable |
( |
SolRational & | sol, |
|
|
bool & | primalFeasible, |
|
|
bool & | dualFeasible, |
|
|
bool & | infeasible, |
|
|
bool & | unbounded, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
solves current problem using double floating-point solver
◆ _solveRealLPAndRecordStatistics()
template<class R >
void _solveRealLPAndRecordStatistics |
( |
volatile bool * | interrupt = nullptr | ) |
|
|
private |
call floating-point solver and update statistics on iterations etc.
◆ _solveRealStable()
solves real LP with recovery mechanism
◆ _storeBasis()
◆ _storeBasisAsOldBasis()
◆ _storeBasisAsOldBasisBoosted()
◆ _storeLastStableBasis()
template<class R >
void _storeLastStableBasis |
( |
bool | vanished | ) |
|
|
private |
◆ _storeLastStableBasisBoosted()
template<class R >
void _storeLastStableBasisBoosted |
( |
bool | vanished | ) |
|
|
private |
◆ _storeLPReal()
stores objective, bounds, and sides of real LP
◆ _storeRealSolutionAsRational()
template<class R >
template<typename T >
stores floating-point solution of original LP as current rational solution and ensure that solution vectors have right dimension; ensure that solution is aligned with basis
◆ _storeSolutionReal()
template<class R >
void _storeSolutionReal |
( |
bool | verify = true | ) |
|
|
private |
stores solution of the real LP; before calling this, the real LP must be loaded in the solver and solved (again)
◆ _storeSolutionRealFromPresol()
template<class R >
void _storeSolutionRealFromPresol |
( |
| ) |
|
|
private |
stores solution from the simplifier because problem vanished in presolving step
◆ _switchRangeType()
switches RANGETYPE_LOWER to RANGETYPE_UPPER and vice versa
◆ _switchToBoosted()
template<class R >
void _switchToBoosted |
( |
| ) |
|
|
private |
disable initial precision solver and switch to boosted solver
◆ _switchToFeasMode()
template<class R >
void _switchToFeasMode |
( |
| ) |
|
|
private |
◆ _switchToStandardMode()
template<class R >
void _switchToStandardMode |
( |
| ) |
|
|
private |
indicate if we are testing feasibility, unboundedness or neither
◆ _switchToUnbdMode()
template<class R >
void _switchToUnbdMode |
( |
| ) |
|
|
private |
◆ _syncLPRational()
template<class R >
void _syncLPRational |
( |
bool | time = true | ) |
|
|
private |
synchronizes rational LP with real LP, i.e., copies real LP to rational LP, without looking at the sync mode
◆ _syncLPReal()
template<class R >
void _syncLPReal |
( |
bool | time = true | ) |
|
|
private |
synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, without looking at the sync mode
◆ _syncRationalSolution()
template<class R >
void _syncRationalSolution |
( |
| ) |
|
|
private |
synchronizes real solution with rational solution, i.e., copies real solution to rational solution
◆ _syncRealSolution()
template<class R >
void _syncRealSolution |
( |
| ) |
|
|
private |
synchronizes rational solution with real solution, i.e., copies (rounded) rational solution to real solution
◆ _transformEquality()
template<class R >
void _transformEquality |
( |
| ) |
|
|
private |
introduces slack variables to transform inequality constraints into equations for both rational and real LP, which should be in sync
◆ _transformFeasibility()
template<class R >
void _transformFeasibility |
( |
| ) |
|
|
private |
transforms LP to feasibility problem by removing the objective function, shifting variables, and homogenizing the right-hand side
◆ _transformUnbounded()
template<class R >
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()
template<class R >
void _unscaleSolutionReal |
( |
SPxLPBase< R > & | LP, |
|
|
bool | persistent = true ) |
|
private |
unscales stored solution to remove internal or external scaling of LP
◆ _untransformEquality()
undoes transformation to equality form
◆ _untransformFeasibility()
template<class R >
void _untransformFeasibility |
( |
SolRational & | sol, |
|
|
bool | infeasible ) |
|
private |
undoes transformation to feasibility problem
◆ _untransformUnbounded()
template<class R >
void _untransformUnbounded |
( |
SolRational & | sol, |
|
|
bool | unbounded ) |
|
private |
undoes transformation to unboundedness problem
◆ _updateBoostingStatistics()
template<class R >
void _updateBoostingStatistics |
( |
| ) |
|
|
private |
◆ _updateReducedCosts()
template<class R >
void _updateReducedCosts |
( |
SolRational & | sol, |
|
|
int & | dualSize, |
|
|
const int & | numCorrectedPrimals ) |
|
private |
updates or recomputes reduced cost values depending on which looks faster; adding one to the length of the dual vector accounts for the objective function vector
◆ _updateSlacks()
template<class R >
void _updateSlacks |
( |
SolRational & | sol, |
|
|
int & | primalSize ) |
|
private |
updates or recomputes slacks depending on which looks faster
◆ _upperFinite()
template<class R >
bool _upperFinite |
( |
const RangeType & | rangeType | ) |
const |
|
private |
checks whether RangeType corresponds to finite upper bound
◆ _verifyObjLimitReal()
template<class R >
void _verifyObjLimitReal |
( |
| ) |
|
|
private |
verify computed obj stop and resolve if necessary
◆ _verifySolutionReal()
template<class R >
void _verifySolutionReal |
( |
| ) |
|
|
private |
verify computed solution and resolve if necessary
◆ addColRational() [1/2]
◆ addColRational() [2/2]
template<class R >
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)
◆ addColReal()
template<class R >
void addColReal |
( |
const LPColBase< R > & | lpcol | ) |
|
◆ addColsRational() [1/2]
◆ addColsRational() [2/2]
template<class R >
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)
◆ addColsReal()
◆ addRowRational() [1/2]
◆ addRowRational() [2/2]
template<class R >
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)
◆ addRowReal()
template<class R >
void addRowReal |
( |
const LPRowBase< R > & | lprow | ) |
|
◆ addRowsRational() [1/2]
◆ addRowsRational() [2/2]
template<class R >
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)
◆ addRowsReal()
◆ areLPsInSync()
template<class R >
bool areLPsInSync |
( |
const bool | checkVecVals = true, |
|
|
const bool | checkMatVals = false, |
|
|
const bool | quiet = false ) const |
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()
template<class R >
bool boolParam |
( |
const BoolParam | param | ) |
const |
returns boolean parameter value
◆ changeBoundsRational() [1/3]
changes vectors of column bounds to lower and upper
◆ changeBoundsRational() [2/3]
template<class R >
void changeBoundsRational |
( |
int | i, |
|
|
const mpq_t * | lower, |
|
|
const mpq_t * | upper ) |
changes bounds of column i to lower and upper (GMP only method)
◆ changeBoundsRational() [3/3]
template<class R >
void changeBoundsRational |
( |
int | i, |
|
|
const Rational & | lower, |
|
|
const Rational & | upper ) |
changes bounds of column i to lower and upper
◆ changeBoundsReal() [1/2]
changes vectors of column bounds to lower and upper
◆ changeBoundsReal() [2/2]
template<class R >
void changeBoundsReal |
( |
int | i, |
|
|
const R & | lower, |
|
|
const R & | upper ) |
changes bounds of column i to lower and upper
◆ changeColRational()
replaces column i with lpcol
◆ changeColReal()
template<class R >
void changeColReal |
( |
int | i, |
|
|
const LPColReal & | lpcol ) |
replaces column i with lpcol
◆ changeElementRational() [1/2]
template<class R >
void changeElementRational |
( |
int | i, |
|
|
int | j, |
|
|
const mpq_t * | val ) |
changes matrix entry in row i and column j to val (GMP only method)
◆ changeElementRational() [2/2]
template<class R >
void changeElementRational |
( |
int | i, |
|
|
int | j, |
|
|
const Rational & | val ) |
changes matrix entry in row i and column j to val
◆ changeElementReal()
template<class R >
void changeElementReal |
( |
int | i, |
|
|
int | j, |
|
|
const R & | val ) |
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]
template<class R >
void changeLhsRational |
( |
int | i, |
|
|
const mpq_t * | lhs ) |
changes left-hand side of row i to lhs (GMP only method)
◆ changeLhsRational() [3/3]
template<class R >
void changeLhsRational |
( |
int | i, |
|
|
const Rational & | lhs ) |
changes left-hand side of row i to lhs
◆ changeLhsReal() [1/2]
changes left-hand side vector for constraints to lhs
◆ changeLhsReal() [2/2]
template<class R >
void changeLhsReal |
( |
int | i, |
|
|
const R & | lhs ) |
changes left-hand side of row i to lhs
◆ changeLowerRational() [1/3]
changes vector of lower bounds to lower
◆ changeLowerRational() [2/3]
template<class R >
void changeLowerRational |
( |
int | i, |
|
|
const mpq_t * | lower ) |
changes lower bound of column i to lower (GMP only method)
◆ changeLowerRational() [3/3]
template<class R >
void changeLowerRational |
( |
int | i, |
|
|
const Rational & | lower ) |
changes lower bound of column i to lower
◆ changeLowerReal() [1/2]
template<class R >
void changeLowerReal |
( |
const VectorBase< R > & | lower | ) |
|
changes vector of lower bounds to lower
◆ changeLowerReal() [2/2]
template<class R >
void changeLowerReal |
( |
int | i, |
|
|
const R & | lower ) |
changes lower bound of column i to lower
◆ changeObjRational() [1/3]
changes objective function vector to obj
◆ changeObjRational() [2/3]
template<class R >
void changeObjRational |
( |
int | i, |
|
|
const mpq_t * | obj ) |
changes objective coefficient of column i to obj (GMP only method)
◆ changeObjRational() [3/3]
template<class R >
void changeObjRational |
( |
int | i, |
|
|
const Rational & | obj ) |
changes objective coefficient of column i to obj
◆ changeObjReal() [1/2]
changes objective function vector to obj
◆ changeObjReal() [2/2]
template<class R >
void changeObjReal |
( |
int | i, |
|
|
const R & | obj ) |
changes objective coefficient of column i to obj
◆ changeRangeRational() [1/3]
changes left- and right-hand side vectors
◆ changeRangeRational() [2/3]
template<class R >
void changeRangeRational |
( |
int | i, |
|
|
const mpq_t * | lhs, |
|
|
const mpq_t * | rhs ) |
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]
template<class R >
void changeRangeReal |
( |
int | i, |
|
|
const R & | lhs, |
|
|
const R & | rhs ) |
changes left- and right-hand side of row i
◆ changeRhsRational() [1/3]
template<class R >
void changeRhsRational |
( |
const mpq_t * | rhs, |
|
|
int | rhsSize ) |
changes right-hand side vector to rhs (GMP only method)
◆ changeRhsRational() [2/3]
changes right-hand side vector to rhs
◆ changeRhsRational() [3/3]
template<class R >
void changeRhsRational |
( |
int | i, |
|
|
const Rational & | rhs ) |
changes right-hand side of row i to rhs
◆ changeRhsReal() [1/2]
changes right-hand side vector to rhs
◆ changeRhsReal() [2/2]
template<class R >
void changeRhsReal |
( |
int | i, |
|
|
const R & | rhs ) |
changes right-hand side of row i to rhs
◆ changeRowRational()
replaces row i with lprow
◆ changeRowReal()
template<class R >
void changeRowReal |
( |
int | i, |
|
|
const LPRowBase< R > & | lprow ) |
replaces row i with lprow
◆ changeUpperRational() [1/3]
changes vector of upper bounds to upper
◆ changeUpperRational() [2/3]
template<class R >
void changeUpperRational |
( |
int | i, |
|
|
const mpq_t * | upper ) |
changes upper bound of column i to upper (GMP only method)
◆ changeUpperRational() [3/3]
template<class R >
void changeUpperRational |
( |
int | i, |
|
|
const Rational & | upper ) |
changes i 'th upper bound to upper
◆ changeUpperReal() [1/2]
template<class R >
void changeUpperReal |
( |
const VectorBase< R > & | upper | ) |
|
changes vector of upper bounds to upper
◆ changeUpperReal() [2/2]
template<class R >
void changeUpperReal |
( |
int | i, |
|
|
const R & | upper ) |
changes i 'th upper bound to upper
◆ checkBasisDualFeasibility()
template<class R >
bool checkBasisDualFeasibility |
( |
VectorBase< R > | feasVec | ) |
|
|
private |
checks the dual feasibility of the current basis
◆ clearBasis()
◆ clearLPRational()
◆ clearLPReal()
◆ coefReal()
template<class R >
R coefReal |
( |
int | row, |
|
|
int | col ) const |
returns (unscaled) coefficient
◆ colVectorRational()
returns vector of column i
◆ colVectorRealInternal()
template<class R >
const SVectorBase< R > & colVectorRealInternal |
( |
int | i | ) |
const |
returns vector of col i , ignoring scaling
◆ computeBasisInverseRational()
template<class R >
bool computeBasisInverseRational |
( |
| ) |
|
compute rational basis inverse; returns true on success
◆ dlcmSizeDualRational()
template<class R >
int dlcmSizeDualRational |
( |
const int | base = 2 | ) |
|
get size of least common multiple of denominators in dual solution
◆ dlcmSizePrimalRational()
template<class R >
int dlcmSizePrimalRational |
( |
const int | base = 2 | ) |
|
get size of least common multiple of denominators in primal solution
◆ dmaxSizeDualRational()
template<class R >
int dmaxSizeDualRational |
( |
const int | base = 2 | ) |
|
get size of largest denominator in dual solution
◆ dmaxSizePrimalRational()
template<class R >
int dmaxSizePrimalRational |
( |
const int | base = 2 | ) |
|
get size of largest denominator in primal solution
◆ getBasis()
gets current basis via arrays of statuses
◆ getBasisInd()
template<class R >
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()
template<class R >
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
◆ getBasisInverseColRational()
computes column c of basis inverse; performs rational factorization if not available; returns true on success
◆ getBasisInverseColReal()
template<class R >
bool getBasisInverseColReal |
( |
int | c, |
|
|
R * | coef, |
|
|
int * | inds = nullptr, |
|
|
int * | ninds = nullptr, |
|
|
bool | unscale = true ) |
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 (nullptr 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()
template<class R >
bool getBasisInverseRowReal |
( |
int | r, |
|
|
R * | coef, |
|
|
int * | inds = nullptr, |
|
|
int * | ninds = nullptr, |
|
|
bool | unscale = true ) |
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 (nullptr 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()
template<class R >
bool getBasisInverseTimesVecReal |
( |
R * | rhs, |
|
|
R * | sol, |
|
|
bool | unscale = true ) |
computes dense solution of basis matrix B * sol = rhs ; returns true on success
◆ getBasisMetric()
template<class R >
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()
template<class R >
bool getBoundViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of bounds; returns true on success
◆ getBoundViolationRational()
◆ getColRational()
◆ getColsRational()
gets columns start , ..., end
◆ getColVectorReal()
template<class R >
void getColVectorReal |
( |
int | i, |
|
|
DSVectorBase< R > & | col ) const |
◆ 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]
template<class R >
bool getDualFarkasRational |
( |
mpq_t * | vector, |
|
|
const int | size ) |
gets the Farkas proof if LP is infeasible; returns true on success (GMP only method)
◆ getDualFarkasRational() [2/2]
◆ getDualFarkasReal()
template<class R >
bool getDualFarkasReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getDualNorms()
template<class R >
bool getDualNorms |
( |
int & | nnormsRow, |
|
|
int & | nnormsCol, |
|
|
R * | norms ) const |
gets steepest edge norms and returns false if they are not available
◆ getDualRational() [1/2]
template<class R >
bool getDualRational |
( |
mpq_t * | vector, |
|
|
const int | size ) |
gets the dual solution vector if available; returns true on success (GMP only method)
◆ getDualRational() [2/2]
◆ getDualReal()
template<class R >
bool getDualReal |
( |
R * | p_vector, |
|
|
int | dim ) |
◆ getDualViolation()
template<class R >
bool getDualViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of dual multipliers; returns true on success
◆ getDualViolationRational()
◆ getEstimatedCondition()
template<class R >
bool getEstimatedCondition |
( |
R & | condition | ) |
|
computes an estimated condition number for the current basis matrix using the power method; returns true on success
◆ getExactCondition()
template<class R >
bool getExactCondition |
( |
R & | condition | ) |
|
computes the exact condition number for the current basis matrix using the power method; returns true on success
◆ getLhsReal()
gets left-hand side vector
◆ getLowerReal()
template<class R >
void getLowerReal |
( |
VectorBase< R > & | lower | ) |
const |
◆ getNdualNorms()
template<class R >
void getNdualNorms |
( |
int & | nnormsRow, |
|
|
int & | nnormsCol ) const |
gets number of available dual norms
◆ getObjRational() [1/2]
template<class R >
void getObjRational |
( |
int | i, |
|
|
Rational & | obj ) const |
gets objective value of column i
◆ getObjRational() [2/2]
gets objective function vector
◆ getObjReal()
gets objective function vector
◆ getPricerName()
template<class R >
const char * getPricerName |
( |
| ) |
|
name of currently loaded pricer
◆ getPrimal()
gets the primal solution vector if available; returns true on success
◆ getPrimalRational() [1/2]
template<class R >
bool getPrimalRational |
( |
mpq_t * | vector, |
|
|
const int | size ) |
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]
template<class R >
bool getPrimalRayRational |
( |
mpq_t * | vector, |
|
|
const int | size ) |
gets the primal ray if LP is unbounded; returns true on success (GMP only method)
◆ getPrimalRayRational() [2/2]
◆ getPrimalRayReal()
template<class R >
bool getPrimalRayReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getPrimalReal()
template<class R >
bool getPrimalReal |
( |
R * | p_vector, |
|
|
int | size ) |
◆ getRatiotesterName()
template<class R >
const char * getRatiotesterName |
( |
| ) |
|
name of currently loaded ratiotester
◆ getRedCost()
gets the vector of reduced cost values if available; returns true on success
◆ getRedCostRational() [1/2]
template<class R >
bool getRedCostRational |
( |
mpq_t * | vector, |
|
|
const int | size ) |
gets the vector of reduced cost values if available; returns true on success (GMP only method)
◆ getRedCostRational() [2/2]
◆ getRedCostReal()
template<class R >
bool getRedCostReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getRedCostViolation()
template<class R >
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()
template<class R >
void getRowVectorReal |
( |
int | i, |
|
|
DSVectorBase< R > & | row ) const |
◆ getRowViolation()
template<class R >
bool getRowViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of constraints; returns true on success
◆ getRowViolationRational()
◆ getScalerName()
template<class R >
const char * getScalerName |
( |
| ) |
|
◆ getSimplifierName()
template<class R >
const char * getSimplifierName |
( |
| ) |
|
◆ getSlacksRational() [1/2]
template<class R >
bool getSlacksRational |
( |
mpq_t * | vector, |
|
|
const int | size ) |
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]
template<class R >
bool getSlacksReal |
( |
R * | p_vector, |
|
|
int | dim ) |
◆ getSlacksReal() [2/2]
gets the vector of slack values if available; returns true on success
◆ getStarterName()
template<class R >
const char * getStarterName |
( |
| ) |
|
◆ getUpperReal()
template<class R >
void getUpperReal |
( |
VectorBase< R > & | upper | ) |
const |
◆ hasBasis()
is an advanced starting basis available?
◆ hasDual()
◆ hasDualFarkas()
template<class R >
bool hasDualFarkas |
( |
| ) |
const |
is Farkas proof of infeasibility available?
◆ hasPrimal()
◆ hasPrimalRay()
template<class R >
bool hasPrimalRay |
( |
| ) |
const |
is a primal unbounded ray available?
◆ hasSol()
◆ ignoreUnscaledViolations()
template<class R >
bool ignoreUnscaledViolations |
( |
| ) |
|
◆ intParam()
template<class R >
int intParam |
( |
const IntParam | param | ) |
const |
returns integer parameter value
◆ isDualFeasible()
template<class R >
bool isDualFeasible |
( |
| ) |
const |
is stored dual solution feasible?
◆ isPrimalFeasible()
template<class R >
bool isPrimalFeasible |
( |
| ) |
const |
is stored primal solution feasible?
◆ lhsRational() [1/2]
returns left-hand side vector
◆ lhsRational() [2/2]
template<class R >
const Rational & lhsRational |
( |
int | i | ) |
const |
returns left-hand side of row i
◆ lhsReal()
returns left-hand side of row i
◆ lhsRealInternal()
returns left-hand side vector, ignoring scaling
◆ loadSettingsFile()
template<class R >
bool loadSettingsFile |
( |
const char * | filename | ) |
|
reads settings file; returns true on success
◆ lowerRational() [1/2]
returns lower bound vector
◆ lowerRational() [2/2]
template<class R >
const Rational & lowerRational |
( |
int | i | ) |
const |
returns lower bound of column i
◆ lowerReal()
template<class R >
R lowerReal |
( |
int | i | ) |
const |
returns lower bound of column i
◆ lowerRealInternal()
template<class R >
const VectorBase< R > & lowerRealInternal |
( |
| ) |
const |
returns lower bound vector
◆ maxAbsNonzeroRational()
template<class R >
Rational maxAbsNonzeroRational |
( |
| ) |
const |
returns biggest non-zero element in absolute value
◆ maxAbsNonzeroReal()
template<class R >
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]
template<class R >
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
◆ maxObjReal()
template<class R >
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()
template<class R >
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
◆ minAbsNonzeroRational()
template<class R >
Rational minAbsNonzeroRational |
( |
| ) |
const |
returns smallest non-zero element in absolute value
◆ minAbsNonzeroReal()
template<class R >
R minAbsNonzeroReal |
( |
| ) |
const |
returns smallest non-zero element in absolute value
◆ multBasis()
template<class R >
bool multBasis |
( |
R * | vec, |
|
|
bool | unscale = true ) |
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()
template<class R >
bool multBasisTranspose |
( |
R * | vec, |
|
|
bool | unscale = true ) |
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()
template<class R >
int numColsRational |
( |
| ) |
const |
◆ numColsReal()
template<class R >
int numColsReal |
( |
| ) |
const |
◆ numIterations()
template<class R >
int numIterations |
( |
| ) |
const |
number of iterations since last call to solve
◆ numIterationsBoosted()
template<class R >
int numIterationsBoosted |
( |
| ) |
const |
number of iterations in higher precision since last call to solve
◆ numNonzeros()
template<class R >
int numNonzeros |
( |
| ) |
const |
returns number of nonzeros
◆ numNonzerosRational()
template<class R >
int numNonzerosRational |
( |
| ) |
const |
◆ numPrecisionBoosts()
template<class R >
int numPrecisionBoosts |
( |
| ) |
const |
number of precision boosts since last call to solve
◆ numRefinements()
template<class R >
int numRefinements |
( |
| ) |
const |
number of iterative refinements
◆ numRows()
◆ numRowsRational()
template<class R >
int numRowsRational |
( |
| ) |
const |
◆ numRowsReal()
template<class R >
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()
template<class R >
SPxSolverBase< R >::Status optimize |
( |
volatile bool * | interrupt = nullptr | ) |
|
◆ parseSettingsString()
template<class R >
bool parseSettingsString |
( |
char * | str | ) |
|
parses one setting string and returns true on success; note that string is modified
◆ precisionBoostTime()
template<class R >
Real precisionBoostTime |
( |
| ) |
const |
time spen in higher precision since last call to solve
◆ printShortStatistics()
template<class R >
void printShortStatistics |
( |
std::ostream & | os | ) |
|
◆ printSolutionStatistics()
template<class R >
void printSolutionStatistics |
( |
std::ostream & | os | ) |
|
prints solution statistics
◆ printSolvingStatistics()
template<class R >
void printSolvingStatistics |
( |
std::ostream & | os | ) |
|
prints statistics on solving process
◆ printStatistics()
template<class R >
void printStatistics |
( |
std::ostream & | os | ) |
|
prints complete statistics
◆ printStatus()
template<class R >
void printStatus |
( |
std::ostream & | os, |
|
|
typename SPxSolverBase< R >::Status | status ) |
◆ printUserSettings()
template<class R >
void printUserSettings |
( |
| ) |
|
print non-default parameter values
◆ printVersion()
template<class R >
void printVersion |
( |
| ) |
const |
prints version and compilation options
◆ randomSeed()
template<class R >
unsigned int randomSeed |
( |
| ) |
const |
returns the current random seed of the solver instance
◆ readBasisFile()
template<class R >
bool readBasisFile |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr ) |
reads basis information from filename and returns true on success; if rowNames and colNames are nullptr , default names are assumed; returns true on success
◆ readFile()
template<class R >
bool readFile |
( |
const char * | filename, |
|
|
NameSet * | rowNames = nullptr, |
|
|
NameSet * | colNames = nullptr, |
|
|
DIdxSet * | intVars = nullptr ) |
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()
template<class R >
void removeColRangeRational |
( |
int | start, |
|
|
int | end, |
|
|
int | perm[] = nullptr ) |
removes columns start to end including both; an array perm of size numColsRational() may be passed as buffer memory
◆ removeColRangeReal()
template<class R >
void removeColRangeReal |
( |
int | start, |
|
|
int | end, |
|
|
int | perm[] = nullptr ) |
removes columns start to end including both; an array perm of size numColsReal() may be passed as buffer memory
◆ removeColRational()
template<class R >
void removeColRational |
( |
int | i | ) |
|
◆ removeColReal()
template<class R >
void removeColReal |
( |
int | i | ) |
|
◆ removeColsRational() [1/2]
template<class R >
void removeColsRational |
( |
int | idx[], |
|
|
int | n, |
|
|
int | perm[] = nullptr ) |
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]
template<class R >
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]
template<class R >
void removeColsReal |
( |
int | idx[], |
|
|
int | n, |
|
|
int | perm[] = nullptr ) |
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]
template<class R >
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()
◆ removeRowRangeRational()
template<class R >
void removeRowRangeRational |
( |
int | start, |
|
|
int | end, |
|
|
int | perm[] = nullptr ) |
removes rows start to end including both; an array perm of size numRowsRational() may be passed as buffer memory
◆ removeRowRangeReal()
template<class R >
void removeRowRangeReal |
( |
int | start, |
|
|
int | end, |
|
|
int | perm[] = nullptr ) |
removes rows start to end including both; an array perm of size numRows() may be passed as buffer memory
◆ removeRowRational()
template<class R >
void removeRowRational |
( |
int | i | ) |
|
◆ removeRowReal()
template<class R >
void removeRowReal |
( |
int | i | ) |
|
◆ removeRowsRational() [1/2]
template<class R >
void removeRowsRational |
( |
int | idx[], |
|
|
int | n, |
|
|
int | perm[] = nullptr ) |
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]
template<class R >
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]
template<class R >
void removeRowsReal |
( |
int | idx[], |
|
|
int | n, |
|
|
int | perm[] = nullptr ) |
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]
template<class R >
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()
◆ resetSettings()
template<class R >
void resetSettings |
( |
const bool | quiet = false, |
|
|
const bool | init = true ) |
resets default parameter settings
◆ rhsRational() [1/2]
returns right-hand side vector
◆ rhsRational() [2/2]
template<class R >
const Rational & rhsRational |
( |
int | i | ) |
const |
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()
template<class R >
LPRowBase< R >::Type rowTypeReal |
( |
int | i | ) |
const |
returns inequality type of row i
◆ rowVectorRational()
◆ rowVectorRealInternal()
template<class R >
const SVectorBase< R > & rowVectorRealInternal |
( |
int | i | ) |
const |
returns vector of row i , ignoring scaling
◆ saveSettingsFile()
template<class R >
bool saveSettingsFile |
( |
const char * | filename, |
|
|
const bool | onlyChanged = false, |
|
|
int | solvemode = 1 ) const |
writes settings file; returns true on success
◆ setBasis()
sets starting basis via arrays of statuses
◆ setBoolParam()
template<class R >
bool setBoolParam |
( |
const BoolParam | param, |
|
|
const bool | value, |
|
|
const bool | init = true ) |
sets boolean parameter value; returns true on success
◆ setDualNorms()
template<class R >
bool setDualNorms |
( |
int | nnormsRow, |
|
|
int | nnormsCol, |
|
|
R * | norms ) |
sets steepest edge norms and returns false if that's not possible
◆ setIntegralityInformation()
template<class R >
void setIntegralityInformation |
( |
int | ncols, |
|
|
int * | intInfo ) |
pass integrality information about the variables to the solver
◆ setIntParam()
template<class R >
bool setIntParam |
( |
const IntParam | param, |
|
|
const int | value, |
|
|
const bool | init = true ) |
sets integer parameter value; returns true on success
◆ setRandomSeed()
template<class R >
void setRandomSeed |
( |
unsigned int | seed | ) |
|
set the random seeds of the solver instance
◆ setRealParam()
template<class R >
bool setRealParam |
( |
const RealParam | param, |
|
|
const Real | value, |
|
|
const bool | init = true ) |
sets real parameter value; returns true on success
◆ setSettings()
template<class R >
bool setSettings |
( |
const Settings & | newSettings, |
|
|
const bool | init = true ) |
sets parameter settings; returns true on success
◆ setTimings()
set statistic timers to a certain type
◆ settings()
returns current parameter settings
◆ solve()
template<class R >
SPxSolverBase< R >::Status solve |
( |
volatile bool * | interrupt = nullptr | ) |
|
◆ solveTime()
time spent in last call to solve
◆ statisticString()
template<class R >
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
◆ tolerances()
template<class R >
const std::shared_ptr< Tolerances > tolerances |
( |
| ) |
const |
returns current tolerances
◆ totalSizeDualRational()
template<class R >
int totalSizeDualRational |
( |
const int | base = 2 | ) |
|
get size of dual solution
◆ totalSizePrimalRational()
template<class R >
int totalSizePrimalRational |
( |
const int | base = 2 | ) |
|
get size of primal solution
◆ upperRational() [1/2]
returns upper bound vector
◆ upperRational() [2/2]
template<class R >
const Rational & upperRational |
( |
int | i | ) |
const |
returns upper bound of column i
◆ upperReal()
template<class R >
R upperReal |
( |
int | i | ) |
const |
returns upper bound of column i
◆ upperRealInternal()
template<class R >
const VectorBase< R > & upperRealInternal |
( |
| ) |
const |
returns upper bound vector
◆ writeBasisFile()
template<class R >
bool writeBasisFile |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr, |
|
|
const bool | cpxFormat = false ) const |
writes basis information to filename ; if rowNames and colNames are nullptr , default names are used; returns true on success
◆ writeDualFileReal()
template<class R >
bool writeDualFileReal |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr, |
|
|
const DIdxSet * | intvars = nullptr, |
|
|
const bool | writeZeroObjective = false ) 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 nullptr , default names are used; if intVars is not nullptr , the variables contained in it are marked as integer; returns true on success
◆ writeFile()
template<class R >
bool writeFile |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr, |
|
|
const DIdxSet * | intvars = nullptr, |
|
|
const bool | unscale = true, |
|
|
const bool | writeZeroObjective = false ) 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 nullptr , default names are used; if intVars is not nullptr , 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 nullptr , default names are used; if intVars is not nullptr , the variables contained in it are marked as integer; returns true on success.
◆ writeFileRational()
template<class R >
bool writeFileRational |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr, |
|
|
const DIdxSet * | intvars = nullptr, |
|
|
const bool | writeZeroObjective = false ) const |
◆ writeFileReal()
template<class R >
bool writeFileReal |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr, |
|
|
const DIdxSet * | intvars = nullptr, |
|
|
const bool | unscale = true, |
|
|
const bool | writeZeroObjective = false ) const |
◆ writeStateRational()
template<class R >
void writeStateRational |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr, |
|
|
const bool | cpxFormat = false, |
|
|
const bool | writeZeroObjective = false ) const |
writes internal LP, basis information, and parameter settings; if rowNames and colNames are nullptr , default names are used
◆ writeStateReal()
template<class R >
void writeStateReal |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr, |
|
|
const bool | cpxFormat = false, |
|
|
const bool | writeZeroObjective = false ) const |
writes internal LP, basis information, and parameter settings; if rowNames and colNames are nullptr , default names are used
◆ _applyPolishing
◆ _basisStatusCols
◆ _basisStatusRows
◆ _beforeLiftCols
◆ _beforeLiftRows
◆ _boostedPricerAuto
◆ _boostedPricerDantzig
◆ _boostedPricerDevex
◆ _boostedPricerParMult
◆ _boostedPricerQuickSteep
◆ _boostedPricerSteep
◆ _boostedRatiotesterBoundFlipping
◆ _boostedRatiotesterFast
◆ _boostedRatiotesterHarris
◆ _boostedRatiotesterTextbook
◆ _boostedScaler
◆ _boostedScalerBiequi
◆ _boostedScalerGeo1
◆ _boostedScalerGeo8
◆ _boostedScalerGeoequi
◆ _boostedScalerLeastsq
◆ _boostedScalerUniequi
◆ _boostedSimplifier
◆ _boostedSimplifierMainSM
◆ _boostedSimplifierPaPILO
◆ _boostedSlufactor
◆ _boostedSolver
◆ _boostingLimitReached
template<class R >
bool _boostingLimitReached |
|
private |
◆ _certificateMode
◆ _colTypes
◆ _currentSettings
◆ _epsFactorPrecisionRatio
template<class R >
Real _epsFactorPrecisionRatio = 1.25 |
|
private |
◆ _epsPivotPrecisionRatio
template<class R >
Real _epsPivotPrecisionRatio = 0.625 |
|
private |
◆ _epsUpdatePrecisionRatio
template<class R >
Real _epsUpdatePrecisionRatio = 1.0 |
|
private |
◆ _epsZeroPrecisionRatio
template<class R >
Real _epsZeroPrecisionRatio = 1.0 |
|
private |
◆ _factorSolNewBasisPrecBoost
template<class R >
bool _factorSolNewBasisPrecBoost |
|
private |
◆ _feasLhs
◆ _feasLower
◆ _feasObj
◆ _feasRhs
◆ _feasUpper
◆ _hasBasis
◆ _hasOldBasis
◆ _hasOldFeasBasis
◆ _hasOldUnbdBasis
◆ _hasSolRational
◆ _hasSolReal
◆ _initialPrecision
template<class R >
int _initialPrecision = 50 |
|
private |
◆ _isRealLPLoaded
◆ _isRealLPScaled
◆ _lastSolveMode
◆ _lastStallPrecBoosts
◆ _manualLhs
◆ _manualLower
◆ _manualObj
◆ _manualRealLP
◆ _manualRhs
◆ _manualUpper
◆ _modLhs
◆ _modLower
◆ _modObj
◆ _modRhs
◆ _modUpper
◆ _nextRatrecPrecBoost
◆ _oldBasisStatusCols
◆ _oldBasisStatusRows
◆ _oldFeasBasisStatusCols
◆ _oldFeasBasisStatusRows
◆ _oldUnbdBasisStatusCols
◆ _oldUnbdBasisStatusRows
◆ _optimizeCalls
◆ _prevIterations
◆ _pricerAuto
◆ _pricerDantzig
◆ _pricerDevex
◆ _pricerParMult
◆ _pricerQuickSteep
◆ _pricerSteep
◆ _primalDualDiff
◆ _rationalFeastol
◆ _rationalLP
◆ _rationalLUSolver
◆ _rationalLUSolverBind
◆ _rationalMaxscaleincr
◆ _rationalNegInfty
◆ _rationalNegone
◆ _rationalOpttol
◆ _rationalPosInfty
◆ _rationalPosone
◆ _rationalZero
◆ _ratiotesterBoundFlipping
◆ _ratiotesterFast
◆ _ratiotesterHarris
◆ _ratiotesterTextbook
◆ _realLP
◆ _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 1687 of file soplex.h.
◆ _status
◆ _storedBasis
◆ _storedBasisStatusCols
◆ _storedBasisStatusRows
◆ _switchedToBoosted
◆ _tauColVector
◆ _tmpBasisStatusCols
◆ _tmpBasisStatusRows
◆ _tolerances
◆ _tolPrecisionRatio
template<class R >
Real _tolPrecisionRatio = 0.65 |
|
private |
ratios for computing the tolerances for precision boosting ratio denotes the proportion of precision used by the tolerance e.g. ratio = 0.65, precision = 100 digits, new tol = 10^(0.65*100)
Definition at line 1785 of file soplex.h.
◆ _unboundedLhs
◆ _unboundedLower
◆ _unboundedRhs
◆ _unboundedUpper
◆ _unitMatrixRational
◆ _unscaleCalls
◆ _workSol
◆ spxout
|