|
Loading...
Searching...
No Matches
#include <statistics.h>
|
|
| Statistics (Timer::TYPE ttype=Timer::USER_TIME) |
| default constructor
|
|
| Statistics (const Statistics &base) |
| copy constructor
|
|
Statistics & | operator= (const Statistics &rhs) |
| assignment operator
|
|
| ~Statistics () |
| destructor
|
|
void | clearAllData () |
| clears all statistics
|
|
void | clearSolvingData () |
| clears statistics on solving process
|
|
void | print (std::ostream &os) |
| prints statistics
|
|
|
| SoPlexBase () |
| default constructor
|
|
| SoPlexBase (const SoPlexBase< R > &rhs) |
| copy constructor
|
|
SoPlexBase< R > & | operator= (const SoPlexBase< R > &rhs) |
| assignment operator
|
|
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) |
|
|
bool | getPrimalRational (mpq_t *vector, const int size) |
| gets the primal solution vector 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)
|
|
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 | getSlacksRational (mpq_t *vector, const int size) |
| gets the vector of slack values if available; 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
|
|
|
|
Timer * | readingTime |
| reading time not included in solving time
|
|
Timer * | solvingTime |
| solving time
|
|
Timer * | preprocessingTime |
| preprocessing time
|
|
Timer * | simplexTime |
| simplex time
|
|
Timer * | syncTime |
| time for synchronization between real and rational LP (included in solving time)
|
|
Timer * | transformTime |
| time for transforming LPs (included in solving time)
|
|
Timer * | rationalTime |
| time for rational LP solving (included in solving time)
|
|
Timer * | initialPrecisionTime |
| solving time with initial precision (included in solving time)
|
|
Timer * | extendedPrecisionTime |
| solving time with extended precision (included in solving time)
|
|
Timer * | reconstructionTime |
| time for rational reconstructions
|
|
Timer * | boostingStepTime |
| time for the precision boosting step: boost, load LP, load basis, decrease tols (included in solving time)
|
|
Timer::TYPE | timerType |
| type of timer (user or wallclock)
|
|
Real | multTimeSparse |
| time for computing A*x exploiting sparsity (setupPupdate(), PRICE step)
|
|
Real | multTimeFull |
| time for computing A*x ignoring sparsity (setupPupdate(), PRICE step)
|
|
Real | multTimeColwise |
| time for computing A*x columnwise (setupPupdate(), PRICE step)
|
|
Real | multTimeUnsetup |
| time for computing A*x w/o sparsity information (setupPupdate(), PRICE step)
|
|
int | multSparseCalls |
| number of products A*x exploiting sparsity (setupPupdate(), PRICE step)
|
|
int | multFullCalls |
| number of products A*x ignoring sparsity (setupPupdate(), PRICE step)
|
|
int | multColwiseCalls |
| number of products A*x columnwise (setupPupdate(), PRICE step)
|
|
int | multUnsetupCalls |
| number of products A*x w/o sparsity information (setupPupdate(), PRICE step)
|
|
Real | luFactorizationTimeReal |
| time for factorizing bases matrices in real precision
|
|
Real | luSolveTimeReal |
| time for solving linear systems in real precision
|
|
Real | luFactorizationTimeRational |
| time for factorizing bases matrices in rational precision
|
|
Real | luSolveTimeRational |
| time for solving linear systems in rational precision
|
|
Real | fpTime |
| time for first floating-point LP solve
|
|
int | iterations |
| number of iterations/pivots
|
|
int | iterationsPrimal |
| number of iterations with Primal
|
|
int | iterationsFromBasis |
| number of iterations from Basis
|
|
int | iterationsPolish |
| number of iterations during solution polishing
|
|
int | iterationsFP |
| number of iterations/pivots in first floating-point solve
|
|
int | boundflips |
| number of dual bound flips
|
|
int | boostedIterations |
| number of iterations/pivots in extended precision
|
|
int | boostedIterationsPrimal |
| number of iterations with Primal
|
|
int | boostedIterationsFromBasis |
| number of iterations from Basis
|
|
int | boostedIterationsPolish |
| number of iterations during solution polishing
|
|
int | boostedBoundflips |
| number of dual bound flips
|
|
int | luFactorizationsReal |
| number of basis matrix factorizations in real precision
|
|
int | luSolvesReal |
| number of (forward and backward) solves with basis matrix in real precision
|
|
int | luFactorizationsRational |
| number of basis matrix factorizations in rational precision
|
|
int | rationalReconstructions |
| number of rational reconstructions performed
|
|
int | refinements |
| number of refinement steps
|
|
int | stallRefinements |
| number of refinement steps without pivots
|
|
int | pivotRefinements |
| number of refinement steps until final basis is reached
|
|
int | feasRefinements |
| number of refinement steps during infeasibility test
|
|
int | unbdRefinements |
| number of refinement steps during undboundedness test
|
|
int | precBoosts |
| number of precision boosts
|
|
int | stallPrecBoosts |
| number of precision boosts without pivots
|
|
int | pivotPrecBoosts |
| number of precision boosts until final basis is reached
|
|
int | feasPrecBoosts |
| number of precision boosts during infeasibility test
|
|
int | unbdPrecBoosts |
| number of precision boosts during undboundedness test
|
|
int | callsReducedProb |
| number of times the reduced problem is solved. This includes the initial solve.
|
|
int | iterationsInit |
| number of iterations in the initial LP
|
|
int | iterationsRedProb |
| number of iterations of the reduced problem
|
|
int | iterationsCompProb |
| number of iterations of the complementary problem
|
|
int | numRedProbRows |
| number of rows in the reduced problem
|
|
int | numRedProbCols |
| number of columns in the reduced problem
|
|
int | degenPivotsPrimal |
| number of primal degenerate pivots
|
|
int | degenPivotsDual |
| number of dual degenerate pivots
|
|
int | degenPivotCandPrimal |
| number of pivoting candidates that will produce a degenerate step in the primal
|
|
int | degenPivotCandDual |
| number of pivoting candidates that will produce a degenerate step in the dual
|
|
R | sumDualDegen |
| the sum of the rate of dual degeneracy at each iteration
|
|
R | sumPrimalDegen |
| the sum of the rate of primal degeneracy at each iteration
|
|
R | totalBoundViol |
| the sum of the bound violations in the original problem using the red prob sol
|
|
R | totalRowViol |
| the sum of the row violations in the original problem using the red prob sol
|
|
R | maxBoundViol |
| the max bound violation in the original problem using the red prob sol
|
|
R | maxRowViol |
| the max row violations in the original problem using the red prob sol
|
|
int | redProbStatus |
| status of the reduced problem
|
|
int | compProbStatus |
| status of the complementary problem
|
|
R | finalCompObj |
| the final objective function of the complementary problem
|
|
R | finalBasisCondition |
| condition number estimate of the optimal basis matrix
|
|
|
|
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
|
|
|
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
|
|
void | _applyScaledBounds (SPxSolverBase< T > &solver, Rational &primalScale) |
| applies scaled bounds
|
|
void | _applyScaledSides (SPxSolverBase< T > &solver, Rational &primalScale) |
| applies scaled sides
|
|
void | _applyScaledObj (SPxSolverBase< T > &solver, Rational &dualScale, SolRational &sol) |
| applies scaled objective function
|
|
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.
|
|
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
|
|
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
|
|
|
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
|
|
enum | BoolParam |
| boolean parameters More...
|
|
enum | IntParam |
| integer parameters More...
|
|
enum | |
| values for parameter OBJSENSE More...
|
|
enum | |
| values for parameter REPRESENTATION More...
|
|
enum | |
| values for parameter ALGORITHM More...
|
|
enum | |
| values for parameter FACTOR_UPDATE_TYPE More...
|
|
enum | |
| values for parameter VERBOSITY More...
|
|
enum | |
| values for parameter SIMPLIFIER More...
|
|
enum | |
| values for parameter SCALER More...
|
|
enum | |
| values for parameter STARTER More...
|
|
enum | |
| values for parameter PRICER More...
|
|
enum | |
| values for parameter RATIOTESTER More...
|
|
enum | |
| values for parameter SYNCMODE More...
|
|
enum | |
| values for parameter READMODE More...
|
|
enum | |
| values for parameter SOLVEMODE More...
|
|
enum | |
| values for parameter CHECKMODE More...
|
|
enum | |
| values for parameter TIMER More...
|
|
enum | |
| values for parameter HYPER_PRICING More...
|
|
enum | |
| values for parameter SOLUTION_POLISHING More...
|
|
enum | RealParam |
| real parameters More...
|
|
template<class R>
class soplex::SoPlexBase< R >::Statistics
Definition at line 43 of file statistics.h.
◆ BP
◆ anonymous enum
values for parameter RATIOTESTER
Definition at line 1285 of file soplex.h.
◆ anonymous enum
values for parameter TIMER
Definition at line 1350 of file soplex.h.
◆ anonymous enum
values for parameter READMODE
Definition at line 1314 of file soplex.h.
◆ anonymous enum
values for parameter SIMPLIFIER
Definition at line 1206 of file soplex.h.
◆ anonymous enum
values for parameter FACTOR_UPDATE_TYPE
Definition at line 1174 of file soplex.h.
◆ anonymous enum
values for parameter PRICER
Definition at line 1263 of file soplex.h.
◆ anonymous enum
values for parameter STARTER
Definition at line 1247 of file soplex.h.
◆ anonymous enum
values for parameter SOLUTION_POLISHING
Definition at line 1376 of file soplex.h.
◆ anonymous enum
values for parameter SCALER
Definition at line 1222 of file soplex.h.
◆ anonymous enum
values for parameter SOLVEMODE
Definition at line 1324 of file soplex.h.
◆ anonymous enum
values for parameter ALGORITHM
Definition at line 1164 of file soplex.h.
◆ anonymous enum
values for parameter SYNCMODE
Definition at line 1301 of file soplex.h.
◆ anonymous enum
values for parameter HYPER_PRICING
Definition at line 1363 of file soplex.h.
◆ anonymous enum
values for parameter VERBOSITY
Definition at line 1184 of file soplex.h.
◆ anonymous enum
values for parameter REPRESENTATION
Definition at line 1151 of file soplex.h.
◆ anonymous enum
values for parameter OBJSENSE
Definition at line 1141 of file soplex.h.
◆ anonymous enum
values for parameter CHECKMODE
Definition at line 1337 of file soplex.h.
◆ BoolParam
boolean parameters
Definition at line 964 of file soplex.h.
◆ IntParam
integer parameters
Definition at line 1049 of file soplex.h.
◆ RangeType
type of bounds and sides
Definition at line 1869 of file soplex.h.
◆ RealParam
◆ Statistics() [1/2]
◆ Statistics() [2/2]
◆ ~Statistics()
destructor
Definition at line 62 of file statistics.h.
References boostingStepTime, extendedPrecisionTime, initialPrecisionTime, preprocessingTime, rationalTime, readingTime, reconstructionTime, simplexTime, solvingTime, soplex::spx_free(), syncTime, and transformTime.
◆ ~SoPlexBase()
◆ _addColReal() [1/2]
adds a single column to the real LP and adjusts basis
◆ _addColReal() [2/2]
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]
void _addRowReal |
( |
const LPRowBase< R > & | lprow | ) |
|
|
private |
adds a single row to the real LP and adjusts basis
◆ _addRowReal() [2/2]
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()
◆ _applyScaledObj()
applies scaled objective function
◆ _applyScaledSides()
◆ _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]
void _changeBoundsReal |
( |
int | i, |
|
|
const R & | lower, |
|
|
const R & | upper ) |
|
private |
changes bounds of column i to lower and upper and adjusts basis
◆ _changeColReal()
void _changeColReal |
( |
int | i, |
|
|
const LPColReal & | lpcol ) |
|
private |
replaces column i with lpcol and adjusts basis
◆ _changeElementReal()
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]
void _changeLhsReal |
( |
const VectorBase< R > & | lhs | ) |
|
|
private |
changes left-hand side vector for constraints to lhs and adjusts basis
◆ _changeLhsReal() [2/2]
void _changeLhsReal |
( |
int | i, |
|
|
const R & | lhs ) |
|
private |
changes left-hand side of row i to lhs and adjusts basis
◆ _changeLowerReal() [1/2]
void _changeLowerReal |
( |
const VectorBase< R > & | lower | ) |
|
|
private |
changes vector of lower bounds to lower and adjusts basis
◆ _changeLowerReal() [2/2]
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]
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]
void _changeRhsReal |
( |
const VectorBase< R > & | rhs | ) |
|
|
private |
changes right-hand side vector to rhs and adjusts basis
◆ _changeRhsReal() [2/2]
void _changeRhsReal |
( |
int | i, |
|
|
const R & | rhs ) |
|
private |
changes right-hand side of row i to rhs and adjusts basis
◆ _changeRowReal()
void _changeRowReal |
( |
int | i, |
|
|
const LPRowBase< R > & | lprow ) |
|
private |
replaces row i with lprow and adjusts basis
◆ _changeUpperReal() [1/2]
void _changeUpperReal |
( |
const VectorBase< R > & | upper | ) |
|
|
private |
changes vector of upper bounds to upper and adjusts basis
◆ _changeUpperReal() [2/2]
void _changeUpperReal |
( |
int | i, |
|
|
const R & | upper ) |
|
private |
changes i 'th upper bound to upper and adjusts basis
◆ _checkBasisScaling()
void _checkBasisScaling |
( |
| ) |
|
|
private |
check correctness of (un)scaled basis matrix operations
◆ _checkRefinementProgress()
checks refinement loop progress
◆ _checkScaling()
void _checkScaling |
( |
SPxLPBase< R > * | origLP | ) |
const |
|
private |
◆ _completeRangeTypesRational()
void _completeRangeTypesRational |
( |
| ) |
|
|
private |
completes range type arrays after adding columns and/or rows
◆ _computeBasisInverseRational()
void _computeBasisInverseRational |
( |
| ) |
|
|
private |
computes rational inverse of basis matrix as defined by _rationalLUSolverBind
◆ _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()
void _computeDualViolation |
( |
SolRational & | sol, |
|
|
Rational & | dualViolation, |
|
|
const bool & | maximizing ) |
|
private |
computes dual violation during the refinement loop
◆ _computeInfeasBox()
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()
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()
corrects dual solution and aligns with basis
◆ _correctPrimalSolution()
void _correctPrimalSolution |
( |
SolRational & | sol, |
|
|
Rational & | primalScale, |
|
|
int & | primalSize, |
|
|
const int & | maxDimRational, |
|
|
VectorBase< T > & | primalReal ) |
|
private |
corrects primal solution and aligns with basis
◆ _disableSimplifierAndScaler()
void _disableSimplifierAndScaler |
( |
| ) |
|
|
private |
disables simplifier and scaler
◆ _enableSimplifierAndScaler()
void _enableSimplifierAndScaler |
( |
| ) |
|
|
private |
enables simplifier and scaler according to current parameters
◆ _ensureDSVectorRationalMemory()
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()
void _ensureRationalLP |
( |
| ) |
|
|
private |
ensures that the rational LP is available; performs no sync
◆ _ensureRealLPLoaded()
void _ensureRealLPLoaded |
( |
| ) |
|
|
private |
ensures that the real LP and the basis are loaded in the solver; performs no sync
◆ _evaluateResult()
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()
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()
void _forceNonbasicToBound |
( |
SolRational & | sol, |
|
|
int & | c, |
|
|
const int & | maxDimRational, |
|
|
bool | toLower ) |
|
private |
forces value of given nonbasic variable to bound
◆ _idxToPerm()
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()
void _invalidateSolution |
( |
| ) |
|
|
private |
◆ _isBoostedConsistent()
bool _isBoostedConsistent |
( |
| ) |
const |
|
private |
checks consistency for the boosted solver
◆ _isBoostedStartingFromSlack()
bool _isBoostedStartingFromSlack |
( |
bool | initialSolve = true | ) |
|
|
private |
return true if slack basis has to be loaded for boosted solver
◆ _isConsistent()
bool _isConsistent |
( |
| ) |
const |
|
private |
◆ _isRefinementOver()
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()
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()
bool _loadBasisFromOldBasis |
( |
bool | boosted | ) |
|
|
private |
◆ _loadRealLP()
void _loadRealLP |
( |
bool | initBasis | ) |
|
|
private |
load original LP and possibly setup a slack basis
◆ _lowerFinite()
bool _lowerFinite |
( |
const RangeType & | rangeType | ) |
const |
|
private |
checks whether RangeType corresponds to finite lower bound
◆ _optimize()
void _optimize |
( |
volatile bool * | interrupt = nullptr | ) |
|
|
private |
◆ _optimizeRational()
void _optimizeRational |
( |
volatile bool * | interrupt = nullptr | ) |
|
|
private |
◆ _parseSettingsLine()
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()
void _performFeasIRStable |
( |
SolRational & | sol, |
|
|
bool & | withDualFarkas, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
performs iterative refinement on the auxiliary problem for testing feasibility
◆ _performOptIRStable()
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()
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()
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()
void _performUnboundedIRStable |
( |
SolRational & | sol, |
|
|
bool & | hasUnboundedRay, |
|
|
bool & | stoppedTime, |
|
|
bool & | stoppedIter, |
|
|
bool & | error ) |
|
private |
performs iterative refinement on the auxiliary problem for testing unboundedness
◆ _preprocessAndSolveReal()
void _preprocessAndSolveReal |
( |
bool | applyPreprocessing, |
|
|
volatile bool * | interrupt = nullptr ) |
|
private |
solves real LP with/without preprocessing
◆ _project()
◆ _rangeToPerm()
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()
◆ _rangeTypeReal()
RangeType _rangeTypeReal |
( |
const R & | lower, |
|
|
const R & | upper ) const |
|
private |
◆ _ratrecAndOrRatfac()
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()
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()
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()
bool _reapplyPersistentScaling |
( |
| ) |
const |
|
private |
check whether persistent scaling is supposed to be reapplied again after unscaling
◆ _recomputeRangeTypesRational()
void _recomputeRangeTypesRational |
( |
| ) |
|
|
private |
recomputes range types from scratch using rational LP
◆ _recomputeRangeTypesReal()
void _recomputeRangeTypesReal |
( |
| ) |
|
|
private |
recomputes range types from scratch using real LP
◆ _reconstructSolutionRational()
attempts rational reconstruction of primal-dual solution
◆ _removeColRangeReal()
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()
void _removeColReal |
( |
int | i | ) |
|
|
private |
◆ _removeColsReal() [1/2]
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]
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()
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()
void _removeRowReal |
( |
int | i | ) |
|
|
private |
removes row i and adjusts basis
◆ _removeRowsReal() [1/2]
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]
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()
void _resetBoostedPrecision |
( |
| ) |
|
|
private |
reset the boosted precision to the default value
◆ _resolveWithoutPreprocessing()
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()
void _setupBoostedSolver |
( |
| ) |
|
|
private |
setup boosted solver before launching iteration
◆ _setupBoostedSolverAfterRecovery()
bool _setupBoostedSolverAfterRecovery |
( |
| ) |
|
|
private |
setup recovery mecanism using multiprecision, return false if maximum precision reached, true otherwise
◆ _solveBoostedRealLPAndRecordStatistics()
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()
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()
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()
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()
void _storeLastStableBasis |
( |
bool | vanished | ) |
|
|
private |
◆ _storeLastStableBasisBoosted()
void _storeLastStableBasisBoosted |
( |
bool | vanished | ) |
|
|
private |
◆ _storeLPReal()
stores objective, bounds, and sides of real LP
◆ _storeRealSolutionAsRational()
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()
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()
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()
void _switchToBoosted |
( |
| ) |
|
|
private |
disable initial precision solver and switch to boosted solver
◆ _switchToFeasMode()
void _switchToFeasMode |
( |
| ) |
|
|
private |
◆ _switchToStandardMode()
void _switchToStandardMode |
( |
| ) |
|
|
private |
indicate if we are testing feasibility, unboundedness or neither
◆ _switchToUnbdMode()
void _switchToUnbdMode |
( |
| ) |
|
|
private |
◆ _syncLPRational()
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()
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()
void _syncRationalSolution |
( |
| ) |
|
|
private |
synchronizes real solution with rational solution, i.e., copies real solution to rational solution
◆ _syncRealSolution()
void _syncRealSolution |
( |
| ) |
|
|
private |
synchronizes rational solution with real solution, i.e., copies (rounded) rational solution to real solution
◆ _transformEquality()
void _transformEquality |
( |
| ) |
|
|
private |
introduces slack variables to transform inequality constraints into equations for both rational and real LP, which should be in sync
◆ _transformFeasibility()
void _transformFeasibility |
( |
| ) |
|
|
private |
transforms LP to feasibility problem by removing the objective function, shifting variables, and homogenizing the right-hand side
◆ _transformUnbounded()
void _transformUnbounded |
( |
| ) |
|
|
private |
transforms LP to unboundedness problem by moving the objective function to the constraints, changing right-hand side and bounds to zero, and adding an auxiliary variable for the decrease in the objective function
◆ _unitVectorRational()
returns pointer to a constant unit vector available until destruction of the SoPlexBase class
◆ _unscaleSolutionReal()
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()
void _untransformFeasibility |
( |
SolRational & | sol, |
|
|
bool | infeasible ) |
|
private |
undoes transformation to feasibility problem
◆ _untransformUnbounded()
void _untransformUnbounded |
( |
SolRational & | sol, |
|
|
bool | unbounded ) |
|
private |
undoes transformation to unboundedness problem
◆ _updateBoostingStatistics()
void _updateBoostingStatistics |
( |
| ) |
|
|
private |
◆ _updateReducedCosts()
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()
void _updateSlacks |
( |
SolRational & | sol, |
|
|
int & | primalSize ) |
|
private |
updates or recomputes slacks depending on which looks faster
◆ _upperFinite()
bool _upperFinite |
( |
const RangeType & | rangeType | ) |
const |
|
private |
checks whether RangeType corresponds to finite upper bound
◆ _verifyObjLimitReal()
void _verifyObjLimitReal |
( |
| ) |
|
|
private |
verify computed obj stop and resolve if necessary
◆ _verifySolutionReal()
void _verifySolutionReal |
( |
| ) |
|
|
private |
verify computed solution and resolve if necessary
◆ addColRational() [1/2]
◆ addColRational() [2/2]
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()
void addColReal |
( |
const LPColBase< R > & | lpcol | ) |
|
◆ addColsRational() [1/2]
◆ addColsRational() [2/2]
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]
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()
void addRowReal |
( |
const LPRowBase< R > & | lprow | ) |
|
◆ addRowsRational() [1/2]
◆ addRowsRational() [2/2]
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()
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()
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]
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]
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]
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()
void changeColReal |
( |
int | i, |
|
|
const LPColReal & | lpcol ) |
replaces column i with lpcol
◆ changeElementRational() [1/2]
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]
void changeElementRational |
( |
int | i, |
|
|
int | j, |
|
|
const Rational & | val ) |
changes matrix entry in row i and column j to val
◆ changeElementReal()
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]
void changeLhsRational |
( |
int | i, |
|
|
const mpq_t * | lhs ) |
changes left-hand side of row i to lhs (GMP only method)
◆ changeLhsRational() [3/3]
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]
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]
void changeLowerRational |
( |
int | i, |
|
|
const mpq_t * | lower ) |
changes lower bound of column i to lower (GMP only method)
◆ changeLowerRational() [3/3]
void changeLowerRational |
( |
int | i, |
|
|
const Rational & | lower ) |
changes lower bound of column i to lower
◆ changeLowerReal() [1/2]
void changeLowerReal |
( |
const VectorBase< R > & | lower | ) |
|
changes vector of lower bounds to lower
◆ changeLowerReal() [2/2]
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]
void changeObjRational |
( |
int | i, |
|
|
const mpq_t * | obj ) |
changes objective coefficient of column i to obj (GMP only method)
◆ changeObjRational() [3/3]
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]
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]
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]
void changeRangeReal |
( |
int | i, |
|
|
const R & | lhs, |
|
|
const R & | rhs ) |
changes left- and right-hand side of row i
◆ changeRhsRational() [1/3]
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]
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]
void changeRhsReal |
( |
int | i, |
|
|
const R & | rhs ) |
changes right-hand side of row i to rhs
◆ changeRowRational()
replaces row i with lprow
◆ changeRowReal()
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]
void changeUpperRational |
( |
int | i, |
|
|
const mpq_t * | upper ) |
changes upper bound of column i to upper (GMP only method)
◆ changeUpperRational() [3/3]
void changeUpperRational |
( |
int | i, |
|
|
const Rational & | upper ) |
changes i 'th upper bound to upper
◆ changeUpperReal() [1/2]
void changeUpperReal |
( |
const VectorBase< R > & | upper | ) |
|
changes vector of upper bounds to upper
◆ changeUpperReal() [2/2]
void changeUpperReal |
( |
int | i, |
|
|
const R & | upper ) |
changes i 'th upper bound to upper
◆ checkBasisDualFeasibility()
bool checkBasisDualFeasibility |
( |
VectorBase< R > | feasVec | ) |
|
|
private |
checks the dual feasibility of the current basis
◆ clearAllData()
◆ clearBasis()
◆ clearLPRational()
◆ clearLPReal()
◆ clearSolvingData()
template<class R>
void clearSolvingData |
( |
| ) |
|
clears statistics on solving process
◆ coefReal()
R coefReal |
( |
int | row, |
|
|
int | col ) const |
returns (unscaled) coefficient
◆ colVectorRational()
returns vector of column i
◆ colVectorRealInternal()
const SVectorBase< R > & colVectorRealInternal |
( |
int | i | ) |
const |
returns vector of col i , ignoring scaling
◆ computeBasisInverseRational()
bool computeBasisInverseRational |
( |
| ) |
|
compute rational basis inverse; returns true on success
◆ dlcmSizeDualRational()
int dlcmSizeDualRational |
( |
const int | base = 2 | ) |
|
get size of least common multiple of denominators in dual solution
◆ dlcmSizePrimalRational()
int dlcmSizePrimalRational |
( |
const int | base = 2 | ) |
|
get size of least common multiple of denominators in primal solution
◆ dmaxSizeDualRational()
int dmaxSizeDualRational |
( |
const int | base = 2 | ) |
|
get size of largest denominator in dual solution
◆ dmaxSizePrimalRational()
int dmaxSizePrimalRational |
( |
const int | base = 2 | ) |
|
get size of largest denominator in primal solution
◆ getBasis()
gets current basis via arrays of statuses
◆ getBasisInd()
void getBasisInd |
( |
int * | bind | ) |
const |
gets the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m
◆ getBasisIndRational()
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()
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()
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()
bool getBasisInverseTimesVecReal |
( |
R * | rhs, |
|
|
R * | sol, |
|
|
bool | unscale = true ) |
computes dense solution of basis matrix B * sol = rhs ; returns true on success
◆ getBasisMetric()
bool getBasisMetric |
( |
R & | metric, |
|
|
int | type = 0 ) |
compute one of several matrix metrics based on the diagonal of the LU factorization type = 0: max/min ratio type = 1: trace of U (sum of diagonal elements) type = 2: determinant (product of diagonal elements)
◆ getBoundViolation()
bool getBoundViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of bounds; returns true on success
◆ getBoundViolationRational()
◆ getColRational()
◆ getColsRational()
gets columns start , ..., end
◆ getColVectorReal()
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]
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()
bool getDualFarkasReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getDualNorms()
bool getDualNorms |
( |
int & | nnormsRow, |
|
|
int & | nnormsCol, |
|
|
R * | norms ) const |
gets steepest edge norms and returns false if they are not available
◆ getDualRational() [1/2]
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()
bool getDualReal |
( |
R * | p_vector, |
|
|
int | dim ) |
◆ getDualViolation()
bool getDualViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of dual multipliers; returns true on success
◆ getDualViolationRational()
◆ getEstimatedCondition()
bool getEstimatedCondition |
( |
R & | condition | ) |
|
computes an estimated condition number for the current basis matrix using the power method; returns true on success
◆ getExactCondition()
bool getExactCondition |
( |
R & | condition | ) |
|
computes the exact condition number for the current basis matrix using the power method; returns true on success
◆ getLhsReal()
gets left-hand side vector
◆ getLowerReal()
void getLowerReal |
( |
VectorBase< R > & | lower | ) |
const |
◆ getNdualNorms()
void getNdualNorms |
( |
int & | nnormsRow, |
|
|
int & | nnormsCol ) const |
gets number of available dual norms
◆ getObjRational() [1/2]
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()
const char * getPricerName |
( |
| ) |
|
name of currently loaded pricer
◆ getPrimal()
gets the primal solution vector if available; returns true on success
◆ getPrimalRational() [1/2]
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]
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()
bool getPrimalRayReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getPrimalReal()
bool getPrimalReal |
( |
R * | p_vector, |
|
|
int | size ) |
◆ getRatiotesterName()
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]
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()
bool getRedCostReal |
( |
R * | vector, |
|
|
int | dim ) |
◆ getRedCostViolation()
bool getRedCostViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of reduced costs; returns true on success
◆ getRedCostViolationRational()
◆ getRhsReal()
gets right-hand side vector
◆ getRowRational()
◆ getRowsRational()
gets rows start , ..., end .
◆ getRowVectorReal()
void getRowVectorReal |
( |
int | i, |
|
|
DSVectorBase< R > & | row ) const |
◆ getRowViolation()
bool getRowViolation |
( |
R & | maxviol, |
|
|
R & | sumviol ) |
gets violation of constraints; returns true on success
◆ getRowViolationRational()
◆ getScalerName()
const char * getScalerName |
( |
| ) |
|
◆ getSimplifierName()
const char * getSimplifierName |
( |
| ) |
|
◆ getSlacksRational() [1/2]
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]
bool getSlacksReal |
( |
R * | p_vector, |
|
|
int | dim ) |
◆ getSlacksReal() [2/2]
gets the vector of slack values if available; returns true on success
◆ getStarterName()
const char * getStarterName |
( |
| ) |
|
◆ getUpperReal()
void getUpperReal |
( |
VectorBase< R > & | upper | ) |
const |
◆ hasBasis()
is an advanced starting basis available?
◆ hasDual()
◆ hasDualFarkas()
bool hasDualFarkas |
( |
| ) |
const |
is Farkas proof of infeasibility available?
◆ hasPrimal()
◆ hasPrimalRay()
bool hasPrimalRay |
( |
| ) |
const |
is a primal unbounded ray available?
◆ hasSol()
is a solution available (not neccessarily feasible)?
◆ ignoreUnscaledViolations()
bool ignoreUnscaledViolations |
( |
| ) |
|
sets the status to OPTIMAL in case the LP has been solved with unscaled violations
Definition at line 642 of file soplex.h.
◆ intParam()
int intParam |
( |
const IntParam | param | ) |
const |
returns integer parameter value
◆ isDualFeasible()
bool isDualFeasible |
( |
| ) |
const |
is stored dual solution feasible?
◆ isPrimalFeasible()
bool isPrimalFeasible |
( |
| ) |
const |
is stored primal solution feasible?
◆ lhsRational() [1/2]
returns left-hand side vector
◆ lhsRational() [2/2]
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()
bool loadSettingsFile |
( |
const char * | filename | ) |
|
reads settings file; returns true on success
◆ lowerRational() [1/2]
returns lower bound vector
◆ lowerRational() [2/2]
const Rational & lowerRational |
( |
int | i | ) |
const |
returns lower bound of column i
◆ lowerReal()
R lowerReal |
( |
int | i | ) |
const |
returns lower bound of column i
◆ lowerRealInternal()
const VectorBase< R > & lowerRealInternal |
( |
| ) |
const |
returns lower bound vector
◆ maxAbsNonzeroRational()
Rational maxAbsNonzeroRational |
( |
| ) |
const |
returns biggest non-zero element in absolute value
◆ maxAbsNonzeroReal()
R maxAbsNonzeroReal |
( |
| ) |
const |
returns biggest non-zero element in absolute value
◆ maxObjRational() [1/2]
returns objective function vector after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
◆ maxObjRational() [2/2]
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()
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()
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()
Rational minAbsNonzeroRational |
( |
| ) |
const |
returns smallest non-zero element in absolute value
◆ minAbsNonzeroReal()
R minAbsNonzeroReal |
( |
| ) |
const |
returns smallest non-zero element in absolute value
◆ multBasis()
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()
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()
int numColsRational |
( |
| ) |
const |
◆ numColsReal()
int numColsReal |
( |
| ) |
const |
◆ numIterations()
int numIterations |
( |
| ) |
const |
number of iterations since last call to solve
◆ numIterationsBoosted()
int numIterationsBoosted |
( |
| ) |
const |
number of iterations in higher precision since last call to solve
◆ numNonzeros()
int numNonzeros |
( |
| ) |
const |
returns number of nonzeros
◆ numNonzerosRational()
int numNonzerosRational |
( |
| ) |
const |
◆ numPrecisionBoosts()
int numPrecisionBoosts |
( |
| ) |
const |
number of precision boosts since last call to solve
◆ numRefinements()
int numRefinements |
( |
| ) |
const |
number of iterative refinements
◆ numRows()
◆ numRowsRational()
int numRowsRational |
( |
| ) |
const |
◆ numRowsReal()
int numRowsReal |
( |
| ) |
const |
◆ objRational()
returns objective value of column i
◆ objReal()
returns objective value of column i
◆ objValueRational()
returns the objective value if a primal solution is available
◆ objValueReal()
returns the objective value if a primal solution is available
◆ operator=() [1/2]
◆ operator=() [2/2]
◆ optimize()
SPxSolverBase< R >::Status optimize |
( |
volatile bool * | interrupt = nullptr | ) |
|
◆ parseSettingsString()
bool parseSettingsString |
( |
char * | str | ) |
|
parses one setting string and returns true on success; note that string is modified
◆ precisionBoostTime()
Real precisionBoostTime |
( |
| ) |
const |
time spen in higher precision since last call to solve
◆ print()
template<class R>
void print |
( |
std::ostream & | os | ) |
|
◆ printShortStatistics()
void printShortStatistics |
( |
std::ostream & | os | ) |
|
◆ printSolutionStatistics()
void printSolutionStatistics |
( |
std::ostream & | os | ) |
|
prints solution statistics
◆ printSolvingStatistics()
void printSolvingStatistics |
( |
std::ostream & | os | ) |
|
prints statistics on solving process
◆ printStatistics()
void printStatistics |
( |
std::ostream & | os | ) |
|
prints complete statistics
◆ printStatus()
void printStatus |
( |
std::ostream & | os, |
|
|
typename SPxSolverBase< R >::Status | status ) |
◆ printUserSettings()
void printUserSettings |
( |
| ) |
|
print non-default parameter values
◆ printVersion()
void printVersion |
( |
| ) |
const |
prints version and compilation options
◆ randomSeed()
unsigned int randomSeed |
( |
| ) |
const |
returns the current random seed of the solver instance
◆ readBasisFile()
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()
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()
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()
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()
void removeColRational |
( |
int | i | ) |
|
◆ removeColReal()
void removeColReal |
( |
int | i | ) |
|
◆ removeColsRational() [1/2]
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]
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]
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]
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()
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()
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()
void removeRowRational |
( |
int | i | ) |
|
◆ removeRowReal()
void removeRowReal |
( |
int | i | ) |
|
◆ removeRowsRational() [1/2]
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]
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]
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]
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()
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]
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()
LPRowBase< R >::Type rowTypeReal |
( |
int | i | ) |
const |
returns inequality type of row i
◆ rowVectorRational()
◆ rowVectorRealInternal()
const SVectorBase< R > & rowVectorRealInternal |
( |
int | i | ) |
const |
returns vector of row i , ignoring scaling
◆ saveSettingsFile()
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()
bool setBoolParam |
( |
const BoolParam | param, |
|
|
const bool | value, |
|
|
const bool | init = true ) |
sets boolean parameter value; returns true on success
◆ setDualNorms()
bool setDualNorms |
( |
int | nnormsRow, |
|
|
int | nnormsCol, |
|
|
R * | norms ) |
sets steepest edge norms and returns false if that's not possible
◆ setIntegralityInformation()
void setIntegralityInformation |
( |
int | ncols, |
|
|
int * | intInfo ) |
pass integrality information about the variables to the solver
◆ setIntParam()
bool setIntParam |
( |
const IntParam | param, |
|
|
const int | value, |
|
|
const bool | init = true ) |
sets integer parameter value; returns true on success
◆ setRandomSeed()
void setRandomSeed |
( |
unsigned int | seed | ) |
|
set the random seeds of the solver instance
◆ setRealParam()
bool setRealParam |
( |
const RealParam | param, |
|
|
const Real | value, |
|
|
const bool | init = true ) |
sets real parameter value; returns true on success
◆ setSettings()
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()
SPxSolverBase< R >::Status solve |
( |
volatile bool * | interrupt = nullptr | ) |
|
◆ solveTime()
time spent in last call to solve
◆ SoPlexBase() [1/2]
◆ SoPlexBase() [2/2]
◆ statisticString()
std::string statisticString |
( |
| ) |
const |
statistical information in form of a string
◆ status()
returns the current solver status
◆ syncLPRational()
synchronizes rational LP with real LP, i.e., copies real LP to rational LP, if sync mode is manual
◆ syncLPReal()
synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, if sync mode is manual
◆ tolerances()
const std::shared_ptr< Tolerances > tolerances |
( |
| ) |
const |
returns current tolerances
◆ totalSizeDualRational()
int totalSizeDualRational |
( |
const int | base = 2 | ) |
|
get size of dual solution
◆ totalSizePrimalRational()
int totalSizePrimalRational |
( |
const int | base = 2 | ) |
|
get size of primal solution
◆ upperRational() [1/2]
returns upper bound vector
◆ upperRational() [2/2]
const Rational & upperRational |
( |
int | i | ) |
const |
returns upper bound of column i
◆ upperReal()
R upperReal |
( |
int | i | ) |
const |
returns upper bound of column i
◆ upperRealInternal()
const VectorBase< R > & upperRealInternal |
( |
| ) |
const |
returns upper bound vector
◆ writeBasisFile()
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()
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()
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()
bool writeFileRational |
( |
const char * | filename, |
|
|
const NameSet * | rowNames = nullptr, |
|
|
const NameSet * | colNames = nullptr, |
|
|
const DIdxSet * | intvars = nullptr, |
|
|
const bool | writeZeroObjective = false ) const |
◆ writeFileReal()
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()
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()
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
bool _boostingLimitReached |
|
private |
◆ _certificateMode
◆ _colTypes
◆ _currentSettings
◆ _epsFactorPrecisionRatio
Real _epsFactorPrecisionRatio |
|
private |
◆ _epsPivotPrecisionRatio
Real _epsPivotPrecisionRatio |
|
private |
◆ _epsUpdatePrecisionRatio
Real _epsUpdatePrecisionRatio |
|
private |
◆ _epsZeroPrecisionRatio
Real _epsZeroPrecisionRatio |
|
private |
◆ _factorSolNewBasisPrecBoost
bool _factorSolNewBasisPrecBoost |
|
private |
◆ _feasLhs
◆ _feasLower
◆ _feasObj
◆ _feasRhs
◆ _feasUpper
◆ _hasBasis
◆ _hasOldBasis
◆ _hasOldFeasBasis
◆ _hasOldUnbdBasis
◆ _hasSolRational
◆ _hasSolReal
◆ _initialPrecision
◆ _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
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
◆ boostedBoundflips
◆ boostedIterations
number of iterations/pivots in extended precision
Definition at line 138 of file statistics.h.
◆ boostedIterationsFromBasis
template<class R>
int boostedIterationsFromBasis |
number of iterations from Basis
Definition at line 140 of file statistics.h.
◆ boostedIterationsPolish
template<class R>
int boostedIterationsPolish |
number of iterations during solution polishing
Definition at line 141 of file statistics.h.
◆ boostedIterationsPrimal
template<class R>
int boostedIterationsPrimal |
number of iterations with Primal
Definition at line 139 of file statistics.h.
◆ boostingStepTime
time for the precision boosting step: boost, load LP, load basis, decrease tols (included in solving time)
Definition at line 115 of file statistics.h.
Referenced by ~Statistics().
◆ boundflips
◆ callsReducedProb
number of times the reduced problem is solved. This includes the initial solve.
Definition at line 159 of file statistics.h.
◆ compProbStatus
status of the complementary problem
Definition at line 176 of file statistics.h.
◆ degenPivotCandDual
number of pivoting candidates that will produce a degenerate step in the dual
Definition at line 168 of file statistics.h.
◆ degenPivotCandPrimal
number of pivoting candidates that will produce a degenerate step in the primal
Definition at line 167 of file statistics.h.
◆ degenPivotsDual
number of dual degenerate pivots
Definition at line 166 of file statistics.h.
◆ degenPivotsPrimal
number of primal degenerate pivots
Definition at line 165 of file statistics.h.
◆ extendedPrecisionTime
template<class R>
Timer* extendedPrecisionTime |
◆ feasPrecBoosts
number of precision boosts during infeasibility test
Definition at line 155 of file statistics.h.
◆ feasRefinements
number of refinement steps during infeasibility test
Definition at line 150 of file statistics.h.
◆ finalBasisCondition
condition number estimate of the optimal basis matrix
Definition at line 180 of file statistics.h.
◆ finalCompObj
the final objective function of the complementary problem
Definition at line 177 of file statistics.h.
◆ fpTime
time for first floating-point LP solve
Definition at line 131 of file statistics.h.
◆ initialPrecisionTime
template<class R>
Timer* initialPrecisionTime |
◆ iterations
◆ iterationsCompProb
number of iterations of the complementary problem
Definition at line 162 of file statistics.h.
◆ iterationsFP
number of iterations/pivots in first floating-point solve
Definition at line 136 of file statistics.h.
◆ iterationsFromBasis
number of iterations from Basis
Definition at line 134 of file statistics.h.
◆ iterationsInit
number of iterations in the initial LP
Definition at line 160 of file statistics.h.
◆ iterationsPolish
number of iterations during solution polishing
Definition at line 135 of file statistics.h.
◆ iterationsPrimal
number of iterations with Primal
Definition at line 133 of file statistics.h.
◆ iterationsRedProb
number of iterations of the reduced problem
Definition at line 161 of file statistics.h.
◆ luFactorizationsRational
template<class R>
int luFactorizationsRational |
number of basis matrix factorizations in rational precision
Definition at line 145 of file statistics.h.
◆ luFactorizationsReal
number of basis matrix factorizations in real precision
Definition at line 143 of file statistics.h.
◆ luFactorizationTimeRational
template<class R>
Real luFactorizationTimeRational |
time for factorizing bases matrices in rational precision
Definition at line 129 of file statistics.h.
◆ luFactorizationTimeReal
template<class R>
Real luFactorizationTimeReal |
time for factorizing bases matrices in real precision
Definition at line 127 of file statistics.h.
◆ luSolvesReal
number of (forward and backward) solves with basis matrix in real precision
Definition at line 144 of file statistics.h.
◆ luSolveTimeRational
time for solving linear systems in rational precision
Definition at line 130 of file statistics.h.
◆ luSolveTimeReal
time for solving linear systems in real precision
Definition at line 128 of file statistics.h.
◆ maxBoundViol
the max bound violation in the original problem using the red prob sol
Definition at line 173 of file statistics.h.
◆ maxRowViol
the max row violations in the original problem using the red prob sol
Definition at line 174 of file statistics.h.
◆ multColwiseCalls
number of products A*x columnwise (setupPupdate(), PRICE step)
Definition at line 124 of file statistics.h.
◆ multFullCalls
number of products A*x ignoring sparsity (setupPupdate(), PRICE step)
Definition at line 123 of file statistics.h.
◆ multSparseCalls
number of products A*x exploiting sparsity (setupPupdate(), PRICE step)
Definition at line 122 of file statistics.h.
◆ multTimeColwise
time for computing A*x columnwise (setupPupdate(), PRICE step)
Definition at line 120 of file statistics.h.
◆ multTimeFull
time for computing A*x ignoring sparsity (setupPupdate(), PRICE step)
Definition at line 119 of file statistics.h.
◆ multTimeSparse
time for computing A*x exploiting sparsity (setupPupdate(), PRICE step)
Definition at line 118 of file statistics.h.
◆ multTimeUnsetup
time for computing A*x w/o sparsity information (setupPupdate(), PRICE step)
Definition at line 121 of file statistics.h.
◆ multUnsetupCalls
number of products A*x w/o sparsity information (setupPupdate(), PRICE step)
Definition at line 125 of file statistics.h.
◆ numRedProbCols
number of columns in the reduced problem
Definition at line 164 of file statistics.h.
◆ numRedProbRows
number of rows in the reduced problem
Definition at line 163 of file statistics.h.
◆ pivotPrecBoosts
number of precision boosts until final basis is reached
Definition at line 154 of file statistics.h.
◆ pivotRefinements
number of refinement steps until final basis is reached
Definition at line 149 of file statistics.h.
◆ precBoosts
◆ preprocessingTime
◆ rationalReconstructions
template<class R>
int rationalReconstructions |
number of rational reconstructions performed
Definition at line 146 of file statistics.h.
◆ rationalTime
◆ readingTime
◆ reconstructionTime
template<class R>
Timer* reconstructionTime |
◆ redProbStatus
◆ refinements
◆ simplexTime
◆ solvingTime
◆ spxout
◆ stallPrecBoosts
number of precision boosts without pivots
Definition at line 153 of file statistics.h.
◆ stallRefinements
number of refinement steps without pivots
Definition at line 148 of file statistics.h.
◆ sumDualDegen
the sum of the rate of dual degeneracy at each iteration
Definition at line 169 of file statistics.h.
◆ sumPrimalDegen
the sum of the rate of primal degeneracy at each iteration
Definition at line 170 of file statistics.h.
◆ syncTime
time for synchronization between real and rational LP (included in solving time)
Definition at line 109 of file statistics.h.
Referenced by ~Statistics().
◆ timerType
type of timer (user or wallclock)
Definition at line 116 of file statistics.h.
◆ totalBoundViol
the sum of the bound violations in the original problem using the red prob sol
Definition at line 171 of file statistics.h.
◆ totalRowViol
the sum of the row violations in the original problem using the red prob sol
Definition at line 172 of file statistics.h.
◆ transformTime
◆ unbdPrecBoosts
number of precision boosts during undboundedness test
Definition at line 156 of file statistics.h.
◆ unbdRefinements
number of refinement steps during undboundedness test
Definition at line 151 of file statistics.h.
|