SoPlex
Loading...
Searching...
No Matches
SoPlexBase< R >::Statistics Class Reference

#include <statistics.h>

Public Member Functions

Construction, resetting, printing
 Statistics (Timer::TYPE ttype=Timer::USER_TIME)
 default constructor
 
 Statistics (const Statistics &base)
 copy constructor
 
Statisticsoperator= (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
 
Construction and destruction
 SoPlexBase ()
 default constructor
 
 SoPlexBase (const SoPlexBase< R > &rhs)
 copy constructor
 
SoPlexBase< R > & operator= (const SoPlexBase< R > &rhs)
 assignment operator
 
virtual ~SoPlexBase ()
 destructor
 
Access to the real LP
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
 
minAbsNonzeroReal () const
 returns smallest non-zero element in absolute value
 
maxAbsNonzeroReal () const
 returns biggest non-zero element in absolute value
 
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
 
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
 
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
 
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
 
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
 
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
 
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
 
Access to the rational LP
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 SVectorRationalrowVectorRational (int i) const
 returns vector of row i
 
const VectorRationalrhsRational () const
 returns right-hand side vector
 
const RationalrhsRational (int i) const
 returns right-hand side of row i
 
const VectorRationallhsRational () const
 returns left-hand side vector
 
const RationallhsRational (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 SVectorRationalcolVectorRational (int i) const
 returns vector of column i
 
const VectorRationalupperRational () const
 returns upper bound vector
 
const RationalupperRational (int i) const
 returns upper bound of column i
 
const VectorRationallowerRational () const
 returns lower bound vector
 
const RationallowerRational (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 VectorRationalmaxObjRational () const
 returns objective function vector after transformation to a maximization problem; since this is how it is stored internally, this is generally faster
 
const RationalmaxObjRational (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
 
Modification of the real LP
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
 
Modification of the rational LP
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
 
Solving and general solution query
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
 
Query for the real solution data
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)
 
Query for the rational solution data
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
 
Access and modification of basis information
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
 
Statistical information
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
 
File I/O
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
 
Statistics
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
 

Public Attributes

Data
TimerreadingTime
 reading time not included in solving time
 
TimersolvingTime
 solving time
 
TimerpreprocessingTime
 preprocessing time
 
TimersimplexTime
 simplex time
 
TimersyncTime
 time for synchronization between real and rational LP (included in solving time)
 
TimertransformTime
 time for transforming LPs (included in solving time)
 
TimerrationalTime
 time for rational LP solving (included in solving time)
 
TimerinitialPrecisionTime
 solving time with initial precision (included in solving time)
 
TimerextendedPrecisionTime
 solving time with extended precision (included in solving time)
 
TimerreconstructionTime
 time for rational reconstructions
 
TimerboostingStepTime
 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
 
sumDualDegen
 the sum of the rate of dual degeneracy at each iteration
 
sumPrimalDegen
 the sum of the rate of primal degeneracy at each iteration
 
totalBoundViol
 the sum of the bound violations in the original problem using the red prob sol
 
totalRowViol
 the sum of the row violations in the original problem using the red prob sol
 
maxBoundViol
 the max bound violation in the original problem using the red prob sol
 
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
 
finalCompObj
 the final objective function of the complementary problem
 
finalBasisCondition
 condition number estimate of the optimal basis matrix
 

Private Member Functions

Constant helper methods
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
 
Non-constant helper methods
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 > &copy)
 
void _convertDataArrayVarStatusToRPrecision (DataArray< typename SPxSolverBase< BP >::VarStatus > &base, DataArray< typename SPxSolverBase< R >::VarStatus > &copy)
 
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
 
Private solving methods implemented in solvereal.cpp
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
 

Private Attributes

Statistics on solving process
Statistics_statistics
 statistics since last call to solveReal() or solveRational()
 
Parameter settings
Settings_currentSettings
 
std::shared_ptr< Tolerances_tolerances
 
Rational _rationalPosInfty
 
Rational _rationalNegInfty
 
Rational _rationalFeastol
 
Rational _rationalOpttol
 
Rational _rationalMaxscaleincr
 
Solution data
SPxSolverBase< R >::Status _status
 
int _lastSolveMode
 
DataArray< typename SPxSolverBase< R >::VarStatus > _basisStatusRows
 
DataArray< typename SPxSolverBase< R >::VarStatus > _basisStatusCols
 
bool _hasOldBasis
 
bool _hasOldFeasBasis
 
bool _hasOldUnbdBasis
 
DataArray< typename SPxSolverBase< R >::VarStatus > _oldBasisStatusRows
 
DataArray< typename SPxSolverBase< R >::VarStatus > _oldBasisStatusCols
 
DataArray< typename SPxSolverBase< R >::VarStatus > _oldFeasBasisStatusRows
 
DataArray< typename SPxSolverBase< R >::VarStatus > _oldFeasBasisStatusCols
 
DataArray< typename SPxSolverBase< R >::VarStatus > _oldUnbdBasisStatusRows
 
DataArray< typename SPxSolverBase< R >::VarStatus > _oldUnbdBasisStatusCols
 
DataArray< typename SPxSolverBase< BP >::VarStatus > _tmpBasisStatusRows
 
DataArray< typename SPxSolverBase< BP >::VarStatus > _tmpBasisStatusCols
 
SolBase< R > _solReal
 
SolRational _solRational
 
SolRational _workSol
 
bool _hasBasis
 
bool _hasSolReal
 
bool _hasSolRational
 

Parameters

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 Settingssettings () const
 returns current parameter settings
 
const std::shared_ptr< Tolerancestolerances () 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...
 

Miscellaneous

void printVersion () const
 prints version and compilation options
 
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.
 
void setRandomSeed (unsigned int seed)
 set the random seeds of the solver instance
 
unsigned int randomSeed () const
 returns the current random seed of the solver instance
 
int _optimizeCalls
 
int _unscaleCalls
 
Rational _rationalPosone
 
Rational _rationalNegone
 
Rational _rationalZero
 

Data for the rational LP

enum  RangeType
 type of bounds and sides More...
 
SPxLPRational_rationalLP
 
SLUFactorRational _rationalLUSolver
 
DataArray< int > _rationalLUSolverBind
 
LPColSetRational _slackCols
 
VectorRational _unboundedLower
 
VectorRational _unboundedUpper
 
VectorRational _unboundedLhs
 
VectorRational _unboundedRhs
 
DSVectorRational _tauColVector
 
VectorRational _feasObj
 
VectorRational _feasLhs
 
VectorRational _feasRhs
 
VectorRational _feasLower
 
VectorRational _feasUpper
 
VectorRational _modLower
 
VectorRational _modUpper
 
VectorRational _modLhs
 
VectorRational _modRhs
 
VectorRational _modObj
 
DSVectorRational _primalDualDiff
 
DataArray< typename SPxSolverBase< R >::VarStatus > _storedBasisStatusRows
 
DataArray< typename SPxSolverBase< R >::VarStatus > _storedBasisStatusCols
 
Array< UnitVectorRational * > _unitMatrixRational
 
bool _storedBasis
 
int _beforeLiftRows
 
int _beforeLiftCols
 
DataArray< RangeType_colTypes
 
DataArray< RangeType_rowTypes
 

Data for the real LP

using BP
 
SPxSolverBase< R > _solver
 
SLUFactor< R > _slufactor
 
SPxMainSM< R > _simplifierMainSM
 
Presol< R > _simplifierPaPILO
 
SPxEquiliSC< R > _scalerUniequi
 
SPxEquiliSC< R > _scalerBiequi
 
SPxGeometSC< R > _scalerGeo1
 
SPxGeometSC< R > _scalerGeo8
 
SPxGeometSC< R > _scalerGeoequi
 
SPxLeastSqSC< R > _scalerLeastsq
 
SPxWeightST< R > _starterWeight
 
SPxSumST< R > _starterSum
 
SPxVectorST< R > _starterVector
 
SPxAutoPR< R > _pricerAuto
 
SPxDantzigPR< R > _pricerDantzig
 
SPxParMultPR< R > _pricerParMult
 
SPxDevexPR< R > _pricerDevex
 
SPxSteepPR< R > _pricerQuickSteep
 
SPxSteepExPR< R > _pricerSteep
 
SPxDefaultRT< R > _ratiotesterTextbook
 
SPxHarrisRT< R > _ratiotesterHarris
 
SPxFastRT< R > _ratiotesterFast
 
SPxBoundFlippingRT< R > _ratiotesterBoundFlipping
 
SPxLPBase< R > * _realLP
 
SPxSimplifier< R > * _simplifier
 
SPxScaler< R > * _scaler
 
SPxStarter< R > * _starter
 
SPxSolverBase< BP_boostedSolver
 
int _initialPrecision
 
bool _boostingLimitReached
 
bool _switchedToBoosted
 
int _certificateMode
 
int _lastStallPrecBoosts
 
bool _factorSolNewBasisPrecBoost
 
int _nextRatrecPrecBoost
 
int _prevIterations
 
Real _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)
 
Real _epsZeroPrecisionRatio
 
Real _epsFactorPrecisionRatio
 
Real _epsUpdatePrecisionRatio
 
Real _epsPivotPrecisionRatio
 
SLUFactor< BP_boostedSlufactor
 
SPxAutoPR< BP_boostedPricerAuto
 
SPxDantzigPR< BP_boostedPricerDantzig
 
SPxParMultPR< BP_boostedPricerParMult
 
SPxDevexPR< BP_boostedPricerDevex
 
SPxSteepPR< BP_boostedPricerQuickSteep
 
SPxSteepExPR< BP_boostedPricerSteep
 
SPxDefaultRT< BP_boostedRatiotesterTextbook
 
SPxHarrisRT< BP_boostedRatiotesterHarris
 
SPxFastRT< BP_boostedRatiotesterFast
 
SPxBoundFlippingRT< BP_boostedRatiotesterBoundFlipping
 
SPxScaler< BP > * _boostedScaler
 
SPxSimplifier< BP > * _boostedSimplifier
 
SPxEquiliSC< BP_boostedScalerUniequi
 
SPxEquiliSC< BP_boostedScalerBiequi
 
SPxGeometSC< BP_boostedScalerGeo1
 
SPxGeometSC< BP_boostedScalerGeo8
 
SPxGeometSC< BP_boostedScalerGeoequi
 
SPxLeastSqSC< BP_boostedScalerLeastsq
 
SPxMainSM< BP_boostedSimplifierMainSM
 
Presol< BP_boostedSimplifierPaPILO
 
bool _isRealLPLoaded
 
bool _isRealLPScaled
 
bool _applyPolishing
 
VectorBase< R > _manualLower
 
VectorBase< R > _manualUpper
 
VectorBase< R > _manualLhs
 
VectorBase< R > _manualRhs
 
VectorBase< R > _manualObj
 
SPxLPBase< R > _manualRealLP
 

Detailed Description

template<class R>
class soplex::SoPlexBase< R >::Statistics

Definition at line 43 of file statistics.h.

Member Typedef Documentation

◆ BP

using BP
private

Definition at line 1753 of file soplex.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

values for parameter FACTOR_UPDATE_TYPE

Definition at line 1174 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter OBJSENSE

Definition at line 1141 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter REPRESENTATION

Definition at line 1151 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter RATIOTESTER

Definition at line 1285 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter STARTER

Definition at line 1247 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter PRICER

Definition at line 1263 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter ALGORITHM

Definition at line 1164 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter TIMER

Definition at line 1350 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter VERBOSITY

Definition at line 1184 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter SOLUTION_POLISHING

Definition at line 1376 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter SIMPLIFIER

Definition at line 1206 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter SCALER

Definition at line 1222 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter CHECKMODE

Definition at line 1337 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter HYPER_PRICING

Definition at line 1363 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter READMODE

Definition at line 1314 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter SOLVEMODE

Definition at line 1324 of file soplex.h.

◆ anonymous enum

anonymous enum

values for parameter SYNCMODE

Definition at line 1301 of file soplex.h.

◆ BoolParam

enum BoolParam

boolean parameters

Definition at line 964 of file soplex.h.

◆ IntParam

enum IntParam

integer parameters

Definition at line 1049 of file soplex.h.

◆ RangeType

enum RangeType
private

type of bounds and sides

Definition at line 1869 of file soplex.h.

◆ RealParam

enum RealParam

real parameters

Definition at line 1389 of file soplex.h.

Constructor & Destructor Documentation

◆ Statistics() [1/2]

template<class R>
Statistics ( Timer::TYPE ttype = Timer::USER_TIME)

default constructor

References Timer::USER_TIME.

Referenced by operator=(), and Statistics().

◆ Statistics() [2/2]

template<class R>
Statistics ( const Statistics & base)

copy constructor

References Statistics().

◆ ~Statistics()

◆ ~SoPlexBase()

virtual ~SoPlexBase ( )
virtual

destructor

Member Function Documentation

◆ _addColReal() [1/2]

void _addColReal ( const LPColReal & lpcol)
private

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()

void _addColsReal ( const LPColSetReal & lpcolset)
private

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()

void _addRowsReal ( const LPRowSetBase< R > & lprowset)
private

adds multiple rows to the real LP and adjusts basis

◆ _applyScaledBounds()

void _applyScaledBounds ( SPxSolverBase< T > & solver,
Rational & primalScale )
private

applies scaled bounds

◆ _applyScaledObj()

void _applyScaledObj ( SPxSolverBase< T > & solver,
Rational & dualScale,
SolRational & sol )
private

applies scaled objective function

◆ _applyScaledSides()

void _applyScaledSides ( SPxSolverBase< T > & solver,
Rational & primalScale )
private

applies scaled sides

◆ _boostPrecision()

bool _boostPrecision ( )
private

increase the multiprecision, return false if maximum precision is reached, true otherwise

◆ _changeBoundsReal() [1/2]

void _changeBoundsReal ( const VectorBase< R > & lower,
const VectorBase< R > & upper )
private

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]

void _changeRangeReal ( const VectorBase< R > & lhs,
const VectorBase< R > & rhs )
private

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()

void _checkRefinementProgress ( Rational & boundsViolation,
Rational & sideViolation,
Rational & redCostViolation,
Rational & dualViolation,
Rational & maxViolation,
Rational & bestViolation,
const Rational & violationImprovementFactor,
int & numFailedRefinements )
private

checks refinement loop progress

◆ _checkScaling()

void _checkScaling ( SPxLPBase< R > * origLP) const
private

check scaling of LP

◆ _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()

void _computeBoundsViolation ( SolRational & sol,
Rational & boundsViolation )
private

computes violation of bounds during the refinement loop

◆ _computeDualScalingFactor()

void _computeDualScalingFactor ( Rational & maxScale,
Rational & primalScale,
Rational & dualScale,
Rational & redCostViolation,
Rational & dualViolation )
private

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()

void _computePrimalScalingFactor ( Rational & maxScale,
Rational & primalScale,
Rational & boundsViolation,
Rational & sideViolation,
Rational & redCostViolation )
private

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()

void _computeSidesViolation ( SolRational & sol,
Rational & sideViolation )
private

computes violation of sides during the refinement loop

◆ _convertDataArrayVarStatusToBoosted()

void _convertDataArrayVarStatusToBoosted ( DataArray< typename SPxSolverBase< R >::VarStatus > & base,
DataArray< typename SPxSolverBase< BP >::VarStatus > & copy )
private
Todo
precision-boosting move some place else converts the given DataArray of VarStatus to boostedPrecision

◆ _convertDataArrayVarStatusToRPrecision()

void _convertDataArrayVarStatusToRPrecision ( DataArray< typename SPxSolverBase< BP >::VarStatus > & base,
DataArray< typename SPxSolverBase< R >::VarStatus > & copy )
private
Todo
precision-boosting move some place else converts the given DataArray of VarStatus to R precision

◆ _correctDualSolution()

void _correctDualSolution ( SPxSolverBase< T > & solver,
SolRational & sol,
const bool & maximizing,
VectorBase< T > & dualReal,
Rational & dualScale,
int & dualSize,
const int & maxDimRational )
private

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()

void _factorizeColumnRational ( SolRational & sol,
DataArray< typename SPxSolverBase< R >::VarStatus > & basisStatusRows,
DataArray< typename SPxSolverBase< R >::VarStatus > & basisStatusCols,
bool & stoppedTime,
bool & stoppedIter,
bool & error,
bool & optimal )
private

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()

bool _inFeasMode ( )
private

◆ _inStandardMode()

bool _inStandardMode ( )
private

check if we are testing feasibility, unboundedness or neither

◆ _inUnbdMode()

bool _inUnbdMode ( )
private

◆ _invalidateSolution()

void _invalidateSolution ( )
private

invalidates solution

◆ _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

checks consistency

◆ _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()

void _lift ( )
private

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

solves the templated LP

◆ _optimizeRational()

void _optimizeRational ( volatile bool * interrupt = nullptr)
private

temporary fix for Rational

◆ _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()

void _project ( SolRational & sol)
private

undoes lifting

◆ _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()

RangeType _rangeTypeRational ( const Rational & lower,
const Rational & upper ) const
private

determines RangeType from rational bounds

◆ _rangeTypeReal()

RangeType _rangeTypeReal ( const R & lower,
const R & upper ) const
private

determines RangeType from real bounds

◆ _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()

bool _reconstructSolutionRational ( SolRational & sol,
DataArray< typename SPxSolverBase< R >::VarStatus > & basisStatusRows,
DataArray< typename SPxSolverBase< R >::VarStatus > & basisStatusCols,
const Rational & denomBoundSquared )
private

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

removes column i

◆ _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()

void _restoreBasis ( )
private

restore basis

◆ _restoreLPReal()

void _restoreLPReal ( )
private

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()

SPxSolverBase< R >::Status _solveRealForRational ( bool fromscratch,
VectorBase< R > & primal,
VectorBase< R > & dual,
DataArray< typename SPxSolverBase< R >::VarStatus > & basisStatusRows,
DataArray< typename SPxSolverBase< R >::VarStatus > & basisStatusCols )
private

solves real LP during iterative refinement

◆ _solveRealForRationalBoosted()

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 )
private

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()

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 )
private

solves real LP with recovery mechanism

◆ _storeBasis()

void _storeBasis ( )
private

store basis

◆ _storeBasisAsOldBasis()

void _storeBasisAsOldBasis ( DataArray< typename SPxSolverBase< R >::VarStatus > & rows,
DataArray< typename SPxSolverBase< R >::VarStatus > & cols )
private

◆ _storeBasisAsOldBasisBoosted()

void _storeBasisAsOldBasisBoosted ( DataArray< typename SPxSolverBase< BP >::VarStatus > & rows,
DataArray< typename SPxSolverBase< BP >::VarStatus > & cols )
private

◆ _storeLastStableBasis()

void _storeLastStableBasis ( bool vanished)
private

◆ _storeLastStableBasisBoosted()

void _storeLastStableBasisBoosted ( bool vanished)
private

◆ _storeLPReal()

void _storeLPReal ( )
private

stores objective, bounds, and sides of real LP

◆ _storeRealSolutionAsRational()

void _storeRealSolutionAsRational ( SolRational & sol,
VectorBase< T > & primalReal,
VectorBase< T > & dualReal,
int & dualSize )
private

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()

RangeType _switchRangeType ( const RangeType & rangeType) const
private

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()

const UnitVectorRational * _unitVectorRational ( const int i)
private

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()

void _untransformEquality ( SolRational & sol)
private

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]

void addColRational ( const LPColRational & lpcol)

adds a single column

◆ 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)

adds a single column

◆ addColsRational() [1/2]

void addColsRational ( const LPColSetRational & lpcolset)

adds multiple columns

◆ 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()

void addColsReal ( const LPColSetBase< R > & lpcolset)

adds multiple columns

◆ addRowRational() [1/2]

void addRowRational ( const LPRowRational & lprow)

adds a single row

◆ 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)

adds a single row

◆ addRowsRational() [1/2]

void addRowsRational ( const LPRowSetRational & lprowset)

adds multiple rows

◆ 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()

void addRowsReal ( const LPRowSetBase< R > & lprowset)

adds multiple rows

◆ 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()

SPxSolverBase< R >::VarStatus basisColStatus ( int col) const

returns basis status for a single column

◆ basisRowStatus()

SPxSolverBase< R >::VarStatus basisRowStatus ( int row) const

returns basis status for a single row

◆ basisStatus()

SPxBasisBase< R >::SPxStatus basisStatus ( ) const

returns the current basis status

◆ boolParam()

bool boolParam ( const BoolParam param) const

returns boolean parameter value

◆ changeBoundsRational() [1/3]

void changeBoundsRational ( const VectorRational & lower,
const VectorRational & upper )

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]

void changeBoundsReal ( const VectorBase< R > & lower,
const VectorBase< R > & upper )

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()

void changeColRational ( int i,
const LPColRational & lpcol )

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]

void changeLhsRational ( const VectorRational & lhs)

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]

void changeLhsReal ( const VectorBase< R > & lhs)

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]

void changeLowerRational ( const VectorRational & lower)

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]

void changeObjRational ( const VectorRational & obj)

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]

void changeObjReal ( const VectorBase< R > & obj)

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]

void changeRangeRational ( const VectorRational & lhs,
const VectorRational & rhs )

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]

void changeRangeRational ( int i,
const Rational & lhs,
const Rational & rhs )

changes left- and right-hand side of row i

◆ changeRangeReal() [1/2]

void changeRangeReal ( const VectorBase< R > & lhs,
const VectorBase< R > & rhs )

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]

void changeRhsRational ( const VectorRational & rhs)

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]

void changeRhsReal ( const VectorBase< R > & rhs)

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()

void changeRowRational ( int i,
const LPRowRational & lprow )

replaces row i with lprow

◆ changeRowReal()

void changeRowReal ( int i,
const LPRowBase< R > & lprow )

replaces row i with lprow

◆ changeUpperRational() [1/3]

void changeUpperRational ( const VectorRational & upper)

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()

template<class R>
void clearAllData ( )

clears all statistics

◆ clearBasis()

void clearBasis ( )

clears starting basis

◆ clearLPRational()

void clearLPRational ( )

clears the LP

◆ clearLPReal()

void clearLPReal ( )

clears the LP

◆ clearSolvingData()

template<class R>
void clearSolvingData ( )

clears statistics on solving process

◆ coefReal()

R coefReal ( int row,
int col ) const

returns (unscaled) coefficient

◆ colVectorRational()

const SVectorRational & colVectorRational ( int i) const

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()

void getBasis ( typename SPxSolverBase< R >::VarStatus rows[],
typename SPxSolverBase< R >::VarStatus cols[] ) const

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()

bool getBasisInverseColRational ( const int c,
SSVectorRational & vec )

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
cwhich column of the basis inverse is computed
coefvalues of result vector (not packed but scattered)
indsindices of result vector (nullptr if not to be used)
nindsnumber of nonzeros in result vector
unscaledetermines whether the result should be unscaled according to the original LP data

◆ getBasisInverseRowRational()

bool getBasisInverseRowRational ( const int r,
SSVectorRational & vec )

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
rwhich row of the basis inverse is computed
coefvalues of result vector (not packed but scattered)
indsindices of result vector (nullptr if not to be used)
nindsnumber of nonzeros in result vector
unscaledetermines whether the result should be unscaled according to the original LP data

◆ getBasisInverseTimesVecRational()

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

◆ 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()

bool getBoundViolationRational ( Rational & maxviol,
Rational & sumviol )

◆ getColRational()

void getColRational ( int i,
LPColRational & lpcol ) const

gets column i

◆ getColsRational()

void getColsRational ( int start,
int end,
LPColSetRational & lpcolset ) const

gets columns start, ..., end

◆ getColVectorReal()

void getColVectorReal ( int i,
DSVectorBase< R > & col ) const

gets vector of col i

◆ getDual()

bool getDual ( VectorBase< R > & vector)

gets the dual solution vector if available; returns true on success

◆ getDualFarkas()

bool getDualFarkas ( VectorBase< R > & vector)

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]

bool getDualFarkasRational ( VectorRational & vector)

◆ 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]

bool getDualRational ( VectorRational & vector)

◆ 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()

bool getDualViolationRational ( Rational & maxviol,
Rational & sumviol )

◆ 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()

void getLhsReal ( VectorBase< R > & lhs) const

gets left-hand side vector

◆ getLowerReal()

void getLowerReal ( VectorBase< R > & lower) const

gets lower bound vector

◆ 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]

void getObjRational ( VectorRational & obj) const

gets objective function vector

◆ getObjReal()

void getObjReal ( VectorBase< R > & obj) const

gets objective function vector

◆ getPricerName()

const char * getPricerName ( )

name of currently loaded pricer

◆ getPrimal()

bool getPrimal ( VectorBase< R > & vector)

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]

bool getPrimalRational ( VectorRational & vector)

◆ getPrimalRay()

bool getPrimalRay ( VectorBase< R > & vector)

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]

bool getPrimalRayRational ( VectorRational & vector)

◆ 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()

bool getRedCost ( VectorBase< R > & vector)

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]

bool getRedCostRational ( VectorRational & vector)

◆ getRedCostReal()

bool getRedCostReal ( R * vector,
int dim )

◆ getRedCostViolation()

bool getRedCostViolation ( R & maxviol,
R & sumviol )

gets violation of reduced costs; returns true on success

◆ getRedCostViolationRational()

bool getRedCostViolationRational ( Rational & maxviol,
Rational & sumviol )

◆ getRhsReal()

void getRhsReal ( VectorBase< R > & rhs) const

gets right-hand side vector

◆ getRowRational()

void getRowRational ( int i,
LPRowRational & lprow ) const

gets row i

◆ getRowsRational()

void getRowsRational ( int start,
int end,
LPRowSetRational & lprowset ) const

gets rows start, ..., end.

◆ getRowVectorReal()

void getRowVectorReal ( int i,
DSVectorBase< R > & row ) const

gets vector of row i

◆ getRowViolation()

bool getRowViolation ( R & maxviol,
R & sumviol )

gets violation of constraints; returns true on success

◆ getRowViolationRational()

bool getRowViolationRational ( Rational & maxviol,
Rational & sumviol )

◆ getScalerName()

const char * getScalerName ( )

name of scaling method

◆ getSimplifierName()

const char * getSimplifierName ( )

name of simplifier

◆ 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]

bool getSlacksRational ( VectorRational & vector)

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]

bool getSlacksReal ( VectorBase< R > & vector)

gets the vector of slack values if available; returns true on success

◆ getStarterName()

const char * getStarterName ( )

name of starter

◆ getUpperReal()

void getUpperReal ( VectorBase< R > & upper) const

gets upper bound vector

◆ hasBasis()

bool hasBasis ( ) const

is an advanced starting basis available?

◆ hasDual()

bool hasDual ( ) const

deprecated: use hasSol() instead

Definition at line 627 of file soplex.h.

◆ hasDualFarkas()

bool hasDualFarkas ( ) const

is Farkas proof of infeasibility available?

◆ hasPrimal()

bool hasPrimal ( ) const

deprecated: use hasSol() instead

Definition at line 621 of file soplex.h.

◆ hasPrimalRay()

bool hasPrimalRay ( ) const

is a primal unbounded ray available?

◆ hasSol()

bool hasSol ( ) const

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]

const VectorRational & lhsRational ( ) const

returns left-hand side vector

◆ lhsRational() [2/2]

const Rational & lhsRational ( int i) const

returns left-hand side of row i

◆ lhsReal()

R lhsReal ( int i) const

returns left-hand side of row i

◆ lhsRealInternal()

const VectorBase< R > & lhsRealInternal ( ) const

returns left-hand side vector, ignoring scaling

◆ loadSettingsFile()

bool loadSettingsFile ( const char * filename)

reads settings file; returns true on success

◆ lowerRational() [1/2]

const VectorRational & lowerRational ( ) const

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]

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

◆ 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
unscaledetermines 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
unscaledetermines whether the result should be unscaled according to the original LP data

◆ numCols()

int numCols ( ) const

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()

int numRows ( ) const

returns number of rows

◆ numRowsRational()

int numRowsRational ( ) const

◆ numRowsReal()

int numRowsReal ( ) const

◆ objRational()

Rational objRational ( int i) const

returns objective value of column i

◆ objReal()

R objReal ( int i) const

returns objective value of column i

◆ objValueRational()

Rational objValueRational ( )

returns the objective value if a primal solution is available

◆ objValueReal()

R objValueReal ( )

returns the objective value if a primal solution is available

◆ operator=() [1/2]

SoPlexBase< R > & operator= ( const SoPlexBase< R > & rhs)

assignment operator

◆ operator=() [2/2]

template<class R>
Statistics & operator= ( const Statistics & rhs)

assignment operator

References Statistics().

◆ optimize()

SPxSolverBase< R >::Status optimize ( volatile bool * interrupt = nullptr)

optimize the given LP

◆ 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)

prints statistics

◆ printShortStatistics()

void printShortStatistics ( std::ostream & os)

prints short statistics

◆ 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 )

prints 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()

Real realParam ( const RealParam param) const

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)

removes column i

◆ removeColReal()

void removeColReal ( int i)

removes column 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)

removes row i

◆ removeRowReal()

void removeRowReal ( int i)

removes row 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]

const VectorRational & rhsRational ( ) const

returns right-hand side vector

◆ rhsRational() [2/2]

const Rational & rhsRational ( int i) const

returns right-hand side of row i

◆ rhsReal()

R rhsReal ( int i) const

returns right-hand side of row i

◆ rhsRealInternal()

const VectorBase< R > & rhsRealInternal ( ) const

returns right-hand side vector, ignoring scaling

◆ rowTypeRational()

LPRowRational::Type rowTypeRational ( int i) const

returns inequality type of row i

◆ rowTypeReal()

LPRowBase< R >::Type rowTypeReal ( int i) const

returns inequality type of row i

◆ rowVectorRational()

const SVectorRational & rowVectorRational ( int i) const

returns vector of row i

◆ 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()

void setBasis ( const typename SPxSolverBase< R >::VarStatus rows[],
const typename SPxSolverBase< R >::VarStatus cols[] )

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()

void setTimings ( const Timer::TYPE ttype)

set statistic timers to a certain type

◆ settings()

const Settings & settings ( ) const

returns current parameter settings

◆ solve()

SPxSolverBase< R >::Status solve ( volatile bool * interrupt = nullptr)

Definition at line 606 of file soplex.h.

◆ solveTime()

Real solveTime ( ) const

time spent in last call to solve

◆ SoPlexBase() [1/2]

default constructor

◆ SoPlexBase() [2/2]

SoPlexBase ( const SoPlexBase< R > & rhs)

copy constructor

◆ statisticString()

std::string statisticString ( ) const

statistical information in form of a string

◆ status()

SPxSolverBase< R >::Status status ( ) const

returns the current solver status

◆ syncLPRational()

void syncLPRational ( )

synchronizes rational LP with real LP, i.e., copies real LP to rational LP, if sync mode is manual

◆ syncLPReal()

void 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]

const VectorRational & upperRational ( ) const

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

Member Data Documentation

◆ _applyPolishing

bool _applyPolishing
private

Definition at line 1825 of file soplex.h.

◆ _basisStatusCols

DataArray<typename SPxSolverBase<R>::VarStatus > _basisStatusCols
private

Definition at line 1900 of file soplex.h.

◆ _basisStatusRows

DataArray<typename SPxSolverBase<R>::VarStatus > _basisStatusRows
private

Definition at line 1899 of file soplex.h.

◆ _beforeLiftCols

int _beforeLiftCols
private

Definition at line 1866 of file soplex.h.

◆ _beforeLiftRows

int _beforeLiftRows
private

Definition at line 1865 of file soplex.h.

◆ _boostedPricerAuto

SPxAutoPR<BP> _boostedPricerAuto
private

Definition at line 1795 of file soplex.h.

◆ _boostedPricerDantzig

SPxDantzigPR<BP> _boostedPricerDantzig
private

Definition at line 1796 of file soplex.h.

◆ _boostedPricerDevex

SPxDevexPR<BP> _boostedPricerDevex
private

Definition at line 1798 of file soplex.h.

◆ _boostedPricerParMult

SPxParMultPR<BP> _boostedPricerParMult
private

Definition at line 1797 of file soplex.h.

◆ _boostedPricerQuickSteep

SPxSteepPR<BP> _boostedPricerQuickSteep
private

Definition at line 1799 of file soplex.h.

◆ _boostedPricerSteep

SPxSteepExPR<BP> _boostedPricerSteep
private

Definition at line 1800 of file soplex.h.

◆ _boostedRatiotesterBoundFlipping

SPxBoundFlippingRT<BP> _boostedRatiotesterBoundFlipping
private

Definition at line 1805 of file soplex.h.

◆ _boostedRatiotesterFast

SPxFastRT<BP> _boostedRatiotesterFast
private

Definition at line 1804 of file soplex.h.

◆ _boostedRatiotesterHarris

SPxHarrisRT<BP> _boostedRatiotesterHarris
private

Definition at line 1803 of file soplex.h.

◆ _boostedRatiotesterTextbook

SPxDefaultRT<BP> _boostedRatiotesterTextbook
private

Definition at line 1802 of file soplex.h.

◆ _boostedScaler

SPxScaler<BP>* _boostedScaler
private

Definition at line 1807 of file soplex.h.

◆ _boostedScalerBiequi

SPxEquiliSC<BP> _boostedScalerBiequi
private

Definition at line 1811 of file soplex.h.

◆ _boostedScalerGeo1

SPxGeometSC<BP> _boostedScalerGeo1
private

Definition at line 1812 of file soplex.h.

◆ _boostedScalerGeo8

SPxGeometSC<BP> _boostedScalerGeo8
private

Definition at line 1813 of file soplex.h.

◆ _boostedScalerGeoequi

SPxGeometSC<BP> _boostedScalerGeoequi
private

Definition at line 1814 of file soplex.h.

◆ _boostedScalerLeastsq

SPxLeastSqSC<BP> _boostedScalerLeastsq
private

Definition at line 1815 of file soplex.h.

◆ _boostedScalerUniequi

SPxEquiliSC<BP> _boostedScalerUniequi
private

Definition at line 1810 of file soplex.h.

◆ _boostedSimplifier

SPxSimplifier<BP>* _boostedSimplifier
private

Definition at line 1808 of file soplex.h.

◆ _boostedSimplifierMainSM

SPxMainSM<BP> _boostedSimplifierMainSM
private

Definition at line 1817 of file soplex.h.

◆ _boostedSimplifierPaPILO

Presol<BP> _boostedSimplifierPaPILO
private

Definition at line 1818 of file soplex.h.

◆ _boostedSlufactor

SLUFactor<BP> _boostedSlufactor
private

Definition at line 1793 of file soplex.h.

◆ _boostedSolver

SPxSolverBase<BP> _boostedSolver
private

Definition at line 1757 of file soplex.h.

◆ _boostingLimitReached

bool _boostingLimitReached
private

Definition at line 1762 of file soplex.h.

◆ _certificateMode

int _certificateMode
private

Definition at line 1767 of file soplex.h.

◆ _colTypes

DataArray< RangeType > _colTypes
private

Definition at line 1887 of file soplex.h.

◆ _currentSettings

Settings* _currentSettings
private

Definition at line 1695 of file soplex.h.

◆ _epsFactorPrecisionRatio

Real _epsFactorPrecisionRatio
private

Definition at line 1787 of file soplex.h.

◆ _epsPivotPrecisionRatio

Real _epsPivotPrecisionRatio
private

Definition at line 1789 of file soplex.h.

◆ _epsUpdatePrecisionRatio

Real _epsUpdatePrecisionRatio
private

Definition at line 1788 of file soplex.h.

◆ _epsZeroPrecisionRatio

Real _epsZeroPrecisionRatio
private

Definition at line 1786 of file soplex.h.

◆ _factorSolNewBasisPrecBoost

bool _factorSolNewBasisPrecBoost
private

Definition at line 1774 of file soplex.h.

◆ _feasLhs

VectorRational _feasLhs
private

Definition at line 1851 of file soplex.h.

◆ _feasLower

VectorRational _feasLower
private

Definition at line 1853 of file soplex.h.

◆ _feasObj

VectorRational _feasObj
private

Definition at line 1850 of file soplex.h.

◆ _feasRhs

VectorRational _feasRhs
private

Definition at line 1852 of file soplex.h.

◆ _feasUpper

VectorRational _feasUpper
private

Definition at line 1854 of file soplex.h.

◆ _hasBasis

bool _hasBasis
private

Definition at line 1935 of file soplex.h.

◆ _hasOldBasis

bool _hasOldBasis
private

Definition at line 1903 of file soplex.h.

◆ _hasOldFeasBasis

bool _hasOldFeasBasis
private

Definition at line 1904 of file soplex.h.

◆ _hasOldUnbdBasis

bool _hasOldUnbdBasis
private

Definition at line 1905 of file soplex.h.

◆ _hasSolRational

bool _hasSolRational
private

Definition at line 1937 of file soplex.h.

◆ _hasSolReal

bool _hasSolReal
private

Definition at line 1936 of file soplex.h.

◆ _initialPrecision

int _initialPrecision
private

Definition at line 1761 of file soplex.h.

◆ _isRealLPLoaded

bool _isRealLPLoaded
private

Definition at line 1822 of file soplex.h.

◆ _isRealLPScaled

bool _isRealLPScaled
private

Definition at line 1824 of file soplex.h.

◆ _lastSolveMode

int _lastSolveMode
private

Definition at line 1897 of file soplex.h.

◆ _lastStallPrecBoosts

int _lastStallPrecBoosts
private

Definition at line 1773 of file soplex.h.

◆ _manualLhs

VectorBase<R> _manualLhs
private

Definition at line 1829 of file soplex.h.

◆ _manualLower

VectorBase<R> _manualLower
private

Definition at line 1827 of file soplex.h.

◆ _manualObj

VectorBase<R> _manualObj
private

Definition at line 1831 of file soplex.h.

◆ _manualRealLP

SPxLPBase<R> _manualRealLP
private

Definition at line 1832 of file soplex.h.

◆ _manualRhs

VectorBase<R> _manualRhs
private

Definition at line 1830 of file soplex.h.

◆ _manualUpper

VectorBase<R> _manualUpper
private

Definition at line 1828 of file soplex.h.

◆ _modLhs

VectorRational _modLhs
private

Definition at line 1857 of file soplex.h.

◆ _modLower

VectorRational _modLower
private

Definition at line 1855 of file soplex.h.

◆ _modObj

VectorRational _modObj
private

Definition at line 1859 of file soplex.h.

◆ _modRhs

VectorRational _modRhs
private

Definition at line 1858 of file soplex.h.

◆ _modUpper

VectorRational _modUpper
private

Definition at line 1856 of file soplex.h.

◆ _nextRatrecPrecBoost

int _nextRatrecPrecBoost
private

Definition at line 1775 of file soplex.h.

◆ _oldBasisStatusCols

DataArray<typename SPxSolverBase<R>::VarStatus > _oldBasisStatusCols
private

Definition at line 1909 of file soplex.h.

◆ _oldBasisStatusRows

DataArray<typename SPxSolverBase<R>::VarStatus > _oldBasisStatusRows
private

Definition at line 1908 of file soplex.h.

◆ _oldFeasBasisStatusCols

DataArray<typename SPxSolverBase<R>::VarStatus > _oldFeasBasisStatusCols
private

Definition at line 1913 of file soplex.h.

◆ _oldFeasBasisStatusRows

DataArray<typename SPxSolverBase<R>::VarStatus > _oldFeasBasisStatusRows
private

Definition at line 1912 of file soplex.h.

◆ _oldUnbdBasisStatusCols

DataArray<typename SPxSolverBase<R>::VarStatus > _oldUnbdBasisStatusCols
private

Definition at line 1917 of file soplex.h.

◆ _oldUnbdBasisStatusRows

DataArray<typename SPxSolverBase<R>::VarStatus > _oldUnbdBasisStatusRows
private

Definition at line 1916 of file soplex.h.

◆ _optimizeCalls

int _optimizeCalls
private

Definition at line 1944 of file soplex.h.

◆ _prevIterations

int _prevIterations
private

Definition at line 1778 of file soplex.h.

◆ _pricerAuto

SPxAutoPR<R> _pricerAuto
private

Definition at line 1724 of file soplex.h.

◆ _pricerDantzig

SPxDantzigPR<R> _pricerDantzig
private

Definition at line 1725 of file soplex.h.

◆ _pricerDevex

SPxDevexPR<R> _pricerDevex
private

Definition at line 1727 of file soplex.h.

◆ _pricerParMult

SPxParMultPR<R> _pricerParMult
private

Definition at line 1726 of file soplex.h.

◆ _pricerQuickSteep

SPxSteepPR<R> _pricerQuickSteep
private

Definition at line 1728 of file soplex.h.

◆ _pricerSteep

SPxSteepExPR<R> _pricerSteep
private

Definition at line 1729 of file soplex.h.

◆ _primalDualDiff

DSVectorRational _primalDualDiff
private

Definition at line 1860 of file soplex.h.

◆ _rationalFeastol

Rational _rationalFeastol
private

Definition at line 1701 of file soplex.h.

◆ _rationalLP

SPxLPRational* _rationalLP
private

Definition at line 1840 of file soplex.h.

◆ _rationalLUSolver

SLUFactorRational _rationalLUSolver
private

Definition at line 1841 of file soplex.h.

◆ _rationalLUSolverBind

DataArray<int> _rationalLUSolverBind
private

Definition at line 1842 of file soplex.h.

◆ _rationalMaxscaleincr

Rational _rationalMaxscaleincr
private

Definition at line 1703 of file soplex.h.

◆ _rationalNegInfty

Rational _rationalNegInfty
private

Definition at line 1700 of file soplex.h.

◆ _rationalNegone

Rational _rationalNegone
private

Definition at line 1948 of file soplex.h.

◆ _rationalOpttol

Rational _rationalOpttol
private

Definition at line 1702 of file soplex.h.

◆ _rationalPosInfty

Rational _rationalPosInfty
private

Definition at line 1699 of file soplex.h.

◆ _rationalPosone

Rational _rationalPosone
private

Definition at line 1947 of file soplex.h.

◆ _rationalZero

Rational _rationalZero
private

Definition at line 1949 of file soplex.h.

◆ _ratiotesterBoundFlipping

SPxBoundFlippingRT<R> _ratiotesterBoundFlipping
private

Definition at line 1733 of file soplex.h.

◆ _ratiotesterFast

SPxFastRT<R> _ratiotesterFast
private

Definition at line 1732 of file soplex.h.

◆ _ratiotesterHarris

SPxHarrisRT<R> _ratiotesterHarris
private

Definition at line 1731 of file soplex.h.

◆ _ratiotesterTextbook

SPxDefaultRT<R> _ratiotesterTextbook
private

Definition at line 1730 of file soplex.h.

◆ _realLP

SPxLPBase<R>* _realLP
private

Definition at line 1735 of file soplex.h.

◆ _rowTypes

DataArray< RangeType > _rowTypes
private

Definition at line 1888 of file soplex.h.

◆ _scaler

SPxScaler<R>* _scaler
private

Definition at line 1737 of file soplex.h.

◆ _scalerBiequi

SPxEquiliSC<R> _scalerBiequi
private

Definition at line 1716 of file soplex.h.

◆ _scalerGeo1

SPxGeometSC<R> _scalerGeo1
private

Definition at line 1717 of file soplex.h.

◆ _scalerGeo8

SPxGeometSC<R> _scalerGeo8
private

Definition at line 1718 of file soplex.h.

◆ _scalerGeoequi

SPxGeometSC<R> _scalerGeoequi
private

Definition at line 1719 of file soplex.h.

◆ _scalerLeastsq

SPxLeastSqSC<R> _scalerLeastsq
private

Definition at line 1720 of file soplex.h.

◆ _scalerUniequi

SPxEquiliSC<R> _scalerUniequi
private

Definition at line 1715 of file soplex.h.

◆ _simplifier

SPxSimplifier<R>* _simplifier
private

Definition at line 1736 of file soplex.h.

◆ _simplifierMainSM

SPxMainSM<R> _simplifierMainSM
private

Definition at line 1713 of file soplex.h.

◆ _simplifierPaPILO

Presol<R> _simplifierPaPILO
private

Definition at line 1714 of file soplex.h.

◆ _slackCols

LPColSetRational _slackCols
private

Definition at line 1844 of file soplex.h.

◆ _slufactor

SLUFactor<R> _slufactor
private

Definition at line 1712 of file soplex.h.

◆ _solRational

SolRational _solRational
private

Definition at line 1932 of file soplex.h.

◆ _solReal

SolBase<R> _solReal
private

Definition at line 1931 of file soplex.h.

◆ _solver

SPxSolverBase<R> _solver
private

Definition at line 1711 of file soplex.h.

◆ _starter

SPxStarter<R>* _starter
private

Definition at line 1738 of file soplex.h.

◆ _starterSum

SPxSumST<R> _starterSum
private

Definition at line 1722 of file soplex.h.

◆ _starterVector

SPxVectorST<R> _starterVector
private

Definition at line 1723 of file soplex.h.

◆ _starterWeight

SPxWeightST<R> _starterWeight
private

Definition at line 1721 of file soplex.h.

◆ _statistics

Statistics* _statistics
private

statistics since last call to solveReal() or solveRational()

Definition at line 1687 of file soplex.h.

◆ _status

SPxSolverBase<R>::Status _status
private

Definition at line 1896 of file soplex.h.

◆ _storedBasis

bool _storedBasis
private

Definition at line 1864 of file soplex.h.

◆ _storedBasisStatusCols

DataArray< typename SPxSolverBase<R>::VarStatus > _storedBasisStatusCols
private

Definition at line 1862 of file soplex.h.

◆ _storedBasisStatusRows

DataArray< typename SPxSolverBase<R>::VarStatus > _storedBasisStatusRows
private

Definition at line 1861 of file soplex.h.

◆ _switchedToBoosted

bool _switchedToBoosted
private

Definition at line 1763 of file soplex.h.

◆ _tauColVector

DSVectorRational _tauColVector
private

Definition at line 1849 of file soplex.h.

◆ _tmpBasisStatusCols

DataArray<typename SPxSolverBase<BP>::VarStatus > _tmpBasisStatusCols
private

Definition at line 1929 of file soplex.h.

◆ _tmpBasisStatusRows

DataArray<typename SPxSolverBase<BP>::VarStatus > _tmpBasisStatusRows
private

Definition at line 1928 of file soplex.h.

◆ _tolerances

std::shared_ptr<Tolerances> _tolerances
private

Definition at line 1697 of file soplex.h.

◆ _tolPrecisionRatio

Real _tolPrecisionRatio
private

ratios for computing the tolerances for precision boosting ratio denotes the proportion of precision used by the tolerance e.g. ratio = 0.65, precision = 100 digits, new tol = 10^(0.65*100)

Definition at line 1785 of file soplex.h.

◆ _unboundedLhs

VectorRational _unboundedLhs
private

Definition at line 1847 of file soplex.h.

◆ _unboundedLower

VectorRational _unboundedLower
private

Definition at line 1845 of file soplex.h.

◆ _unboundedRhs

VectorRational _unboundedRhs
private

Definition at line 1848 of file soplex.h.

◆ _unboundedUpper

VectorRational _unboundedUpper
private

Definition at line 1846 of file soplex.h.

◆ _unitMatrixRational

Array< UnitVectorRational* > _unitMatrixRational
private

Definition at line 1863 of file soplex.h.

◆ _unscaleCalls

int _unscaleCalls
private

Definition at line 1945 of file soplex.h.

◆ _workSol

SolRational _workSol
private

Definition at line 1933 of file soplex.h.

◆ boostedBoundflips

template<class R>
int boostedBoundflips

number of dual bound flips

Definition at line 142 of file statistics.h.

◆ boostedIterations

template<class R>
int 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

template<class R>
Timer* 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

template<class R>
int boundflips

number of dual bound flips

Definition at line 137 of file statistics.h.

◆ callsReducedProb

template<class R>
int callsReducedProb

number of times the reduced problem is solved. This includes the initial solve.

Definition at line 159 of file statistics.h.

◆ compProbStatus

template<class R>
int compProbStatus

status of the complementary problem

Definition at line 176 of file statistics.h.

◆ degenPivotCandDual

template<class R>
int degenPivotCandDual

number of pivoting candidates that will produce a degenerate step in the dual

Definition at line 168 of file statistics.h.

◆ degenPivotCandPrimal

template<class R>
int degenPivotCandPrimal

number of pivoting candidates that will produce a degenerate step in the primal

Definition at line 167 of file statistics.h.

◆ degenPivotsDual

template<class R>
int degenPivotsDual

number of dual degenerate pivots

Definition at line 166 of file statistics.h.

◆ degenPivotsPrimal

template<class R>
int degenPivotsPrimal

number of primal degenerate pivots

Definition at line 165 of file statistics.h.

◆ extendedPrecisionTime

template<class R>
Timer* extendedPrecisionTime

solving time with extended precision (included in solving time)

Definition at line 113 of file statistics.h.

Referenced by ~Statistics().

◆ feasPrecBoosts

template<class R>
int feasPrecBoosts

number of precision boosts during infeasibility test

Definition at line 155 of file statistics.h.

◆ feasRefinements

template<class R>
int feasRefinements

number of refinement steps during infeasibility test

Definition at line 150 of file statistics.h.

◆ finalBasisCondition

template<class R>
R finalBasisCondition

condition number estimate of the optimal basis matrix

Definition at line 180 of file statistics.h.

◆ finalCompObj

template<class R>
R finalCompObj

the final objective function of the complementary problem

Definition at line 177 of file statistics.h.

◆ fpTime

template<class R>
Real fpTime

time for first floating-point LP solve

Definition at line 131 of file statistics.h.

◆ initialPrecisionTime

template<class R>
Timer* initialPrecisionTime

solving time with initial precision (included in solving time)

Definition at line 112 of file statistics.h.

Referenced by ~Statistics().

◆ iterations

template<class R>
int iterations

number of iterations/pivots

Definition at line 132 of file statistics.h.

◆ iterationsCompProb

template<class R>
int iterationsCompProb

number of iterations of the complementary problem

Definition at line 162 of file statistics.h.

◆ iterationsFP

template<class R>
int iterationsFP

number of iterations/pivots in first floating-point solve

Definition at line 136 of file statistics.h.

◆ iterationsFromBasis

template<class R>
int iterationsFromBasis

number of iterations from Basis

Definition at line 134 of file statistics.h.

◆ iterationsInit

template<class R>
int iterationsInit

number of iterations in the initial LP

Definition at line 160 of file statistics.h.

◆ iterationsPolish

template<class R>
int iterationsPolish

number of iterations during solution polishing

Definition at line 135 of file statistics.h.

◆ iterationsPrimal

template<class R>
int iterationsPrimal

number of iterations with Primal

Definition at line 133 of file statistics.h.

◆ iterationsRedProb

template<class R>
int 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

template<class R>
int 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

template<class R>
int luSolvesReal

number of (forward and backward) solves with basis matrix in real precision

Definition at line 144 of file statistics.h.

◆ luSolveTimeRational

template<class R>
Real luSolveTimeRational

time for solving linear systems in rational precision

Definition at line 130 of file statistics.h.

◆ luSolveTimeReal

template<class R>
Real luSolveTimeReal

time for solving linear systems in real precision

Definition at line 128 of file statistics.h.

◆ maxBoundViol

template<class R>
R maxBoundViol

the max bound violation in the original problem using the red prob sol

Definition at line 173 of file statistics.h.

◆ maxRowViol

template<class R>
R maxRowViol

the max row violations in the original problem using the red prob sol

Definition at line 174 of file statistics.h.

◆ multColwiseCalls

template<class R>
int multColwiseCalls

number of products A*x columnwise (setupPupdate(), PRICE step)

Definition at line 124 of file statistics.h.

◆ multFullCalls

template<class R>
int multFullCalls

number of products A*x ignoring sparsity (setupPupdate(), PRICE step)

Definition at line 123 of file statistics.h.

◆ multSparseCalls

template<class R>
int multSparseCalls

number of products A*x exploiting sparsity (setupPupdate(), PRICE step)

Definition at line 122 of file statistics.h.

◆ multTimeColwise

template<class R>
Real multTimeColwise

time for computing A*x columnwise (setupPupdate(), PRICE step)

Definition at line 120 of file statistics.h.

◆ multTimeFull

template<class R>
Real multTimeFull

time for computing A*x ignoring sparsity (setupPupdate(), PRICE step)

Definition at line 119 of file statistics.h.

◆ multTimeSparse

template<class R>
Real multTimeSparse

time for computing A*x exploiting sparsity (setupPupdate(), PRICE step)

Definition at line 118 of file statistics.h.

◆ multTimeUnsetup

template<class R>
Real multTimeUnsetup

time for computing A*x w/o sparsity information (setupPupdate(), PRICE step)

Definition at line 121 of file statistics.h.

◆ multUnsetupCalls

template<class R>
int multUnsetupCalls

number of products A*x w/o sparsity information (setupPupdate(), PRICE step)

Definition at line 125 of file statistics.h.

◆ numRedProbCols

template<class R>
int numRedProbCols

number of columns in the reduced problem

Definition at line 164 of file statistics.h.

◆ numRedProbRows

template<class R>
int numRedProbRows

number of rows in the reduced problem

Definition at line 163 of file statistics.h.

◆ pivotPrecBoosts

template<class R>
int pivotPrecBoosts

number of precision boosts until final basis is reached

Definition at line 154 of file statistics.h.

◆ pivotRefinements

template<class R>
int pivotRefinements

number of refinement steps until final basis is reached

Definition at line 149 of file statistics.h.

◆ precBoosts

template<class R>
int precBoosts

number of precision boosts

Definition at line 152 of file statistics.h.

◆ preprocessingTime

template<class R>
Timer* preprocessingTime

preprocessing time

Definition at line 107 of file statistics.h.

Referenced by ~Statistics().

◆ rationalReconstructions

template<class R>
int rationalReconstructions

number of rational reconstructions performed

Definition at line 146 of file statistics.h.

◆ rationalTime

template<class R>
Timer* rationalTime

time for rational LP solving (included in solving time)

Definition at line 111 of file statistics.h.

Referenced by ~Statistics().

◆ readingTime

template<class R>
Timer* readingTime

reading time not included in solving time

Definition at line 105 of file statistics.h.

Referenced by ~Statistics().

◆ reconstructionTime

template<class R>
Timer* reconstructionTime

time for rational reconstructions

Definition at line 114 of file statistics.h.

Referenced by ~Statistics().

◆ redProbStatus

template<class R>
int redProbStatus

status of the reduced problem

Definition at line 175 of file statistics.h.

◆ refinements

template<class R>
int refinements

number of refinement steps

Definition at line 147 of file statistics.h.

◆ simplexTime

template<class R>
Timer* simplexTime

simplex time

Definition at line 108 of file statistics.h.

Referenced by ~Statistics().

◆ solvingTime

template<class R>
Timer* solvingTime

solving time

Definition at line 106 of file statistics.h.

Referenced by ~Statistics().

◆ spxout

SPxOut spxout
mutable

Definition at line 1575 of file soplex.h.

◆ stallPrecBoosts

template<class R>
int stallPrecBoosts

number of precision boosts without pivots

Definition at line 153 of file statistics.h.

◆ stallRefinements

template<class R>
int stallRefinements

number of refinement steps without pivots

Definition at line 148 of file statistics.h.

◆ sumDualDegen

template<class R>
R sumDualDegen

the sum of the rate of dual degeneracy at each iteration

Definition at line 169 of file statistics.h.

◆ sumPrimalDegen

template<class R>
R sumPrimalDegen

the sum of the rate of primal degeneracy at each iteration

Definition at line 170 of file statistics.h.

◆ syncTime

template<class R>
Timer* 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

template<class R>
Timer::TYPE timerType

type of timer (user or wallclock)

Definition at line 116 of file statistics.h.

◆ totalBoundViol

template<class R>
R 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

template<class R>
R 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

template<class R>
Timer* transformTime

time for transforming LPs (included in solving time)

Definition at line 110 of file statistics.h.

Referenced by ~Statistics().

◆ unbdPrecBoosts

template<class R>
int unbdPrecBoosts

number of precision boosts during undboundedness test

Definition at line 156 of file statistics.h.

◆ unbdRefinements

template<class R>
int unbdRefinements

number of refinement steps during undboundedness test

Definition at line 151 of file statistics.h.