Loading...
Searching...
No Matches
soplex.h
Go to the documentation of this file.
101///@todo implement statistical info (time, factor time, iters, ...) since last call to solveReal() or solveRational() (Ambros?)
108///@todo integrate rational SPxSolver and distinguish between original and transformed rational LP
227 /// returns objective function vector after transformation to a maximization problem; since this is how it is stored
231 /// returns objective value of column \p i after transformation to a maximization problem; since this is how it is
313 /// returns objective function vector after transformation to a maximization problem; since this is how it is stored
317 /// returns objective value of column \p i after transformation to a maximization problem; since this is how it is
393 /// removes all rows with an index \p i such that \p perm[i] < 0; upon completion, \p perm[i] >= 0 indicates the
394 /// new index where row \p i has been moved to; note that \p perm must point to an array of size at least
398 /// remove all rows with indices in array \p idx of size \p n; an array \p perm of size #numRows() may be passed
402 /// removes rows \p start to \p end including both; an array \p perm of size #numRows() may be passed as buffer
409 /// removes all columns with an index \p i such that \p perm[i] < 0; upon completion, \p perm[i] >= 0 indicates the
410 /// new index where column \p i has been moved to; note that \p perm must point to an array of size at least
414 /// remove all columns with indices in array \p idx of size \p n; an array \p perm of size #numColsReal() may be
418 /// removes columns \p start to \p end including both; an array \p perm of size #numColsReal() may be passed as
425 /// synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, if sync mode is manual
562 /// removes all rows with an index \p i such that \p perm[i] < 0; upon completion, \p perm[i] >= 0 indicates the new
563 /// index where row \p i has been moved to; note that \p perm must point to an array of size at least
567 /// remove all rows with indices in array \p idx of size \p n; an array \p perm of size #numRowsRational() may be
571 /// removes rows \p start to \p end including both; an array \p perm of size #numRowsRational() may be passed as
578 /// removes all columns with an index \p i such that \p perm[i] < 0; upon completion, \p perm[i] >= 0 indicates the
579 /// new index where column \p i has been moved to; note that \p perm must point to an array of size at least
583 /// remove all columns with indices in array \p idx of size \p n; an array \p perm of size #numColsRational() may be
587 /// removes columns \p start to \p end including both; an array \p perm of size #numColsRational() may be passed as
594 /// synchronizes rational LP with real LP, i.e., copies real LP to rational LP, if sync mode is manual
731 /// gets the vector of reduced cost values if available; returns true on success (GMP only method)
778 /// gets the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m
788 /// computes an estimated condition number for the current basis matrix using the power method; returns true on success
791 /// computes the exact condition number for the current basis matrix using the power method; returns true on success
799 /// @param unscale determines whether the result should be unscaled according to the original LP data
808 /// @param unscale determines whether the result should be unscaled according to the original LP data
817 /// @param unscale determines whether the result should be unscaled according to the original LP data
822 /// @param unscale determines whether the result should be unscaled according to the original LP data
828 /// gets an array of indices for the columns of the rational basis matrix; bind[i] >= 0 means that the i-th column of
829 /// the basis matrix contains variable bind[i]; bind[i] < 0 means that the i-th column of the basis matrix contains
830 /// the slack variable for row -bind[i]-1; performs rational factorization if not available; returns true on success
833 /// computes row r of basis inverse; performs rational factorization if not available; returns true on success
836 /// computes column c of basis inverse; performs rational factorization if not available; returns true on success
839 /// computes solution of basis matrix B * sol = rhs; performs rational factorization if not available; returns true
886 /// reads LP file in LP or MPS format according to READMODE parameter; gets row names, column names, and
893 /// writes real LP to file; LP or MPS format is chosen from the extension in \p filename; if \p rowNames and \p
894 /// colNames are \c NULL, default names are used; if \p intVars is not \c NULL, the variables contained in it are
897 /// writes rational LP to file; LP or MPS format is chosen from the extension in \p filename; if \p rowNames and \p
898 /// colNames are \c NULL, default names are used; if \p intVars is not \c NULL, the variables contained in it are
907 bool writeFileReal(const char* filename, const NameSet* rowNames = 0, const NameSet* colNames = 0,
910 /// writes the dual of the real LP to file; LP or MPS format is chosen from the extension in \p filename;
911 /// if \p rowNames and \p colNames are \c NULL, default names are used; if \p intVars is not \c NULL,
916 /// reads basis information from \p filename and returns true on success; if \p rowNames and \p colNames are \c NULL,
918 bool readBasisFile(const char* filename, const NameSet* rowNames = 0, const NameSet* colNames = 0);
920 /// writes basis information to \p filename; if \p rowNames and \p colNames are \c NULL, default names are used;
922 bool writeBasisFile(const char* filename, const NameSet* rowNames = 0, const NameSet* colNames = 0,
925 /// writes internal LP, basis information, and parameter settings; if \p rowNames and \p colNames are \c NULL,
927 void writeStateReal(const char* filename, const NameSet* rowNames = 0, const NameSet* colNames = 0,
930 /// writes internal LP, basis information, and parameter settings; if \p rowNames and \p colNames are \c NULL,
950 /// should dual infeasibility be tested in order to try to return a dual solution even if primal infeasible?
956 /// should the decomposition based dual simplex be used to solve the LP? Setting this to true forces the solve mode to
1105 };
1118 };
1128 };
1138 };
1160 };
1176 };
1201 };
1217 };
1239 };
1255 };
1268 };
1278 };
1291 };
1304 };
1317 };
1330 };
1343 };
1387 /// lower threshold in lifting (nonzero matrix coefficients with smaller absolute value will be reformulated)
1390 /// upper threshold in lifting (nonzero matrix coefficients with larger absolute value will be reformulated)
1393 /// sparse pricing threshold (\#violations < dimension * SPARSITY_THRESHOLD activates sparse pricing)
1396 /// threshold on number of rows vs. number of columns for switching from column to row representations in auto mode
1405 /// refactor threshold for nonzeros in last factorized basis matrix compared to updated basis matrix
1408 /// refactor threshold for fill-in in current factor update compared to fill-in in last factorization
1559 bool setRationalParam(const RationalParam param, const Rational value, const bool init = true);
1691 bool _isRealLPLoaded; // true indicates that the original LP is loaded in the _solver variable, hence all actions
1818 _compSolver; // adding a solver to contain the complementary problem. It is too confusing to switch
1830 _transformedRows; // a set of the original rows that have been transformed using the original basis.
1832 SPxRowId _compSlackDualRowId; // row id in the dual of complementary problem related to the slack column.
1833 bool* _decompReducedProbRows; // flag to indicate the inclusion of a row in the reduced problem.
1834 bool* _decompReducedProbCols; // flag to indicate the inclusion of a col in the reduced problem.
1852 DataArray < SPxColId > _decompFixedVarDualIDs; // the column ids related to the fixed variables.
1857 _decompCompPrimalFixedVarIDs; // the column ids related to the fixed variables in the complementary primal.
1859 _decompCompPrimalVarBoundIDs; // the column ids related to the variable bound constraints in the complementary primal.
1868 int* _decompViolatedBounds; // the violated bounds given by the solution to the IDS reduced problem
1869 int* _decompViolatedRows; // the violated rows given by the solution to the IDS reduced problem
1872 int* _fixedOrigVars; // the original variables that are at their bounds in the reduced problem.
1875 int _nPrimalCols; // the number of original problem columns included in the complementary problem
1876 int _nElimPrimalRows; // the number of primal rows from the original problem eliminated from the complementary prob
1877 int _nDualRows; // the number of dual rows in the complementary problem. NOTE: _nPrimalRows = _nDualCols
1878 int _nDualCols; // the number of dual columns in the complementary problem. NOTE: _nPrimalRows = _nDualCols
1879 int _nCompPrimalRows; // the number of rows in the complementary primal problem. NOTE: _nPrimalRows = _nCompPrimalRows
1880 int _nCompPrimalCols; // the number of dual columns in the complementary problem. NOTE: _nPrimalCols = _nCompPrimalCols
2052 /// removes all rows with an index \p i such that \p perm[i] < 0; upon completion, \p perm[i] >= 0 indicates the
2053 /// new index where row \p i has been moved to; note that \p perm must point to an array of size at least
2057 /// remove all rows with indices in array \p idx of size \p n; an array \p perm of size #numRows() may be passed
2061 /// removes rows \p start to \p end including both; an array \p perm of size #numRows() may be passed as buffer
2068 /// removes all columns with an index \p i such that \p perm[i] < 0; upon completion, \p perm[i] >= 0 indicates the
2069 /// new index where column \p i has been moved to; note that \p perm must point to an array of size at least
2073 /// remove all columns with indices in array \p idx of size \p n; an array \p perm of size #numColsReal() may be
2077 /// removes columns \p start to \p end including both; an array \p perm of size #numColsReal() may be passed as
2099 /// reads real LP in LP or MPS format from file and returns true on success; gets row names, column names, and
2104 /// reads rational LP in LP or MPS format from file and returns true on success; gets row names, column names, and
2118 /// synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, without looking at the sync mode
2121 /// synchronizes rational LP with real LP, i.e., copies real LP to rational LP, without looking at the sync mode
2124 /// synchronizes rational solution with real solution, i.e., copies (rounded) rational solution to real solution
2127 /// synchronizes real solution with rational solution, i.e., copies real solution to rational solution
2130 /// returns pointer to a constant unit vector available until destruction of the SoPlexBase class
2133 /// parses one line in a settings file and returns true on success; note that the string is modified
2163 /// reduces matrix coefficient in absolute value by the lifting procedure of Thiele et al. 2013
2181 /// introduces slack variables to transform inequality constraints into equations for both rational and real LP,
2188 /// transforms LP to unboundedness problem by moving the objective function to the constraints, changing right-hand
2189 /// side and bounds to zero, and adding an auxiliary variable for the decrease in the objective function
2195 /// transforms LP to feasibility problem by removing the objective function, shifting variables, and homogenizing the
2204 Given constraints of the form \f$ lhs <= Ax <= rhs \f$, a farkas proof y should satisfy \f$ y^T A = 0 \f$ and
2205 \f$ y_+^T lhs - y_-^T rhs > 0 \f$, where \f$ y_+, y_- \f$ denote the positive and negative parts of \f$ y \f$.
2206 If \f$ y \f$ is approximate, it may not satisfy \f$ y^T A = 0 \f$ exactly, but the proof is still valid as long
2213 we may therefore calculate \f$ y^T A \f$ and \f$ y_+^T lhs - y_-^T rhs \f$ exactly and check if the upper and lower
2214 bounds on \f$ x \f$ imply that all feasible \f$ x \f$ satisfy (*), and if not then compute bounds on \f$ x \f$ to
2223 \f$ B \f$ can be increased by iteratively including variable bounds smaller than \f$ B \f$. The speed of this
2224 method can be further improved by using interval arithmetic for all computations. For related information see
2232 typename SPxSolverBase<R>::Status _solveRealForRational(bool fromscratch, VectorBase<R>& primal,
2238 typename SPxSolverBase<R>::Status _solveRealStable(bool acceptUnbounded, bool acceptInfeasible,
2275 /// loads original problem into solver and solves again after it has been solved to optimality with preprocessing
2281 /// stores solution of the real LP; before calling this, the real LP must be loaded in the solver and solved (again)
2305 /// creating copies of the original problem that will be manipulated to form the reduced and complementary problems
2318 void _decompSimplifyAndSolve(SPxSolverBase<R>& solver, SLUFactor<R>& sluFactor, bool fromScratch,
2321 /// loads original problem into solver and solves again after it has been solved to optimality with preprocessing
2325 /// identifies the columns of the row-form basis that correspond to rows with zero dual multipliers.
2326 void _getZeroDualMultiplierIndices(VectorBase<R> feasVector, int* nonposind, int* colsforremoval,
2355 void _updateDecompReducedProblem(R objVal, VectorBase<R> dualVector, VectorBase<R> redcostVector,
2359 /// update the reduced problem with additional columns and rows based upon the violated original bounds and rows
2414 void printDecompDisplayLine(SPxSolverBase<R>& solver, const SPxOut::Verbosity origVerb, bool force,
2435 /// function to build a basis for the original problem as given by the solution to the reduced problem
2439 /// function to retrieve the original problem row basis status from the reduced and complementary problems
Collection of dense, sparse, and semi-sparse vectors. Definition rational.h:229 Definition spxpapilo.h:32 Implementation of Sparse Linear Solver with Rational precision. Definition slufactor_rational.h:51 Bound flipping ratio test ("long step dual") for SoPlex. Definition spxboundflippingrt.h:61 Wrapper for several output streams. A verbosity level is used to decide which stream to use and wheth... Definition spxout.h:73 int _intParamValues[SoPlexBase< R >::INTPARAM_COUNT] array of current integer parameter values Definition soplex.h:1509 static struct soplex::SoPlexBase::Settings::BoolParam boolParam bool _boolParamValues[SoPlexBase< R >::BOOLPARAM_COUNT] array of current boolean parameter values Definition soplex.h:1506 static struct soplex::SoPlexBase::Settings::IntParam intParam Settings & operator=(const Settings &settings) assignment operator Real _realParamValues[SoPlexBase< R >::REALPARAM_COUNT] array of current real parameter values Definition soplex.h:1512 static struct soplex::SoPlexBase::Settings::RealParam realParam Definition soplex.h:121 bool getBasisInverseTimesVecRational(const SVectorRational &rhs, SSVectorRational &sol) computes solution of basis matrix B * sol = rhs; performs rational factorization if not available; re... void _performOptIRStable(SolRational &sol, bool acceptUnbounded, bool acceptInfeasible, int minRounds, bool &primalFeasible, bool &dualFeasible, bool &infeasible, bool &unbounded, bool &stoppedTime, bool &stoppedIter, bool &error) solves current problem with iterative refinement and recovery mechanism bool _isSolveStopped(bool &stoppedTime, bool &stoppedIter) const should solving process be stopped? bool getDualNorms(int &nnormsRow, int &nnormsCol, R *norms) const gets steepest edge norms and returns false if they are not available void _changeColReal(int i, const LPColReal &lpcol) replaces column i with lpcol and adjusts basis 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 void _setComplementaryPrimalOriginalObjective() updating the complementary primal problem with the original objective function void _untransformFeasibility(SolRational &sol, bool infeasible) undoes transformation to feasibility problem bool getRowViolation(R &maxviol, R &sumviol) gets violation of constraints; returns true on success DataArray< SPxRowId > _decompElimPrimalRowIDs Definition soplex.h:1847 void _resolveWithoutPreprocessing(typename SPxSimplifier< R >::Result simplificationStatus) loads original problem into solver and solves again after it has been solved to optimality with prepr... R objValueReal() returns the objective value if a primal solution is available 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... void _storeSolutionReal(bool verify=true) stores solution of the real LP; before calling this, the real LP must be loaded in the solver and sol... void getObjReal(VectorBase< R > &obj) const gets objective function vector void _identifyComplementaryPrimalFixedPrimalVars(int *currFixedVars) removing the dual columns related to the fixed variables void _preprocessAndSolveReal(bool applyPreprocessing, volatile bool *interrupt=NULL) solves real LP with/without preprocessing bool multBasisTranspose(R *vec, bool unscale=true) multiply with transpose of basis matrix; vec * B^T (inplace) void _rangeToPerm(int start, int end, int *perm, int permSize) const creates a permutation for removing rows/columns from a range of indices void changeColRational(int i, const LPColRational &lpcol) replaces column i with lpcol void setTimings(const Timer::TYPE ttype) set statistic timers to a certain type const VectorBase< R > & lhsRealInternal() const returns left-hand side vector, ignoring scaling bool getSlacksReal(VectorBase< R > &vector) gets the vector of slack values if available; returns true on success 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 pa... @ FPOPTTOL working tolerance for optimality in floating-point solver during iterative refinement Definition soplex.h:1382 @ SPARSITY_THRESHOLD sparse pricing threshold (#violations < dimension * SPARSITY_THRESHOLD activates sparse pricing) Definition soplex.h:1394 @ LIFTMAXVAL upper threshold in lifting (nonzero matrix coefficients with larger absolute value will be reformulat... Definition soplex.h:1391 @ FPFEASTOL working tolerance for feasibility in floating-point solver during iterative refinement Definition soplex.h:1379 @ LIFTMINVAL lower threshold in lifting (nonzero matrix coefficients with smaller absolute value will be reformula... Definition soplex.h:1388 @ REPRESENTATION_SWITCH threshold on number of rows vs. number of columns for switching from column to row representations in... Definition soplex.h:1397 @ REFAC_UPDATE_FILL refactor threshold for fill-in in current factor update compared to fill-in in last factorization Definition soplex.h:1409 @ MINRED minimal reduction (sum of removed rows/cols) to continue simplification Definition soplex.h:1403 @ MIN_MARKOWITZ minimal Markowitz threshold to control sparsity/stability in LU factorization Definition soplex.h:1421 @ REFAC_MEM_FACTOR refactor threshold for memory growth in factorization since last refactorization Definition soplex.h:1412 @ SIMPLIFIER_MODIFYROWFAC minimal modification threshold to apply presolve reductions Definition soplex.h:1424 @ REFAC_BASIS_NNZ refactor threshold for nonzeros in last factorized basis matrix compared to updated basis matrix Definition soplex.h:1406 @ LEASTSQ_ACRCY accuracy of conjugate gradient method in least squares scaling (higher value leads to more iterations... Definition soplex.h:1415 bool getDualViolation(R &maxviol, R &sumviol) gets violation of dual multipliers; returns true on success void _enableSimplifierAndScaler() enables simplifier and scaler according to current parameters void _updateComplementaryDualSlackColCoeff() updating the slack column coefficients to adjust for equality constraints bool getSlacksReal(R *p_vector, int dim) DataArray< typename SPxSolverBase< R >::VarStatus > _basisStatusRows Definition soplex.h:1922 void changeLhsReal(const VectorBase< R > &lhs) changes left-hand side vector for constraints to lhs void addRowsRational(const LPRowSetRational &lprowset) adds multiple rows void changeRhsRational(const VectorRational &rhs) changes right-hand side vector to rhs @ DECOMP_MAXADDEDROWS the maximum number of rows that are added in each iteration of the decomposition based simplex Definition soplex.h:1079 @ LEASTSQ_MAXROUNDS maximum number of conjugate gradient iterations in least square scaling Definition soplex.h:1070 @ DECOMP_ITERLIMIT the number of iterations before the decomposition simplex initialisation is terminated. Definition soplex.h:1076 @ DECOMP_DISPLAYFREQ the iteration frequency at which the decomposition solve output is displayed. Definition soplex.h:1082 @ REPRESENTATION type of computational form, i.e., column or row representation Definition soplex.h:1007 @ RATFAC_MINSTALLS minimum number of stalling refinements since last pivot to trigger rational factorization Definition soplex.h:1067 void changeUpperRational(const VectorRational &upper) changes vector of upper bounds to upper void _addColReal(const LPColReal &lpcol) adds a single column to the real LP and adjusts basis DataArray< typename SPxSolverBase< R >::VarStatus > _storedBasisStatusRows Definition soplex.h:1730 bool getDualRational(mpq_t *vector, const int size) gets the dual solution vector if available; returns true on success (GMP only method) void changeElementRational(int i, int j, const Rational &val) changes matrix entry in row i and column j to val void _solveDecompReducedProblem() solves the reduced problem LPRowRational::Type rowTypeRational(int i) const returns inequality type of row i void getObjRational(int i, Rational &obj) const gets objective value of column i void _ensureRealLPLoaded() ensures that the real LP and the basis are loaded in the solver; performs no sync void changeLhsRational(int i, const mpq_t *lhs) changes left-hand side of row i to lhs (GMP only method) const Rational & upperRational(int i) const returns upper bound of column i bool getSlacksRational(mpq_t *vector, const int size) gets the vector of slack values if available; returns true on success (GMP only method) void printSolvingStatistics(std::ostream &os) prints statistics on solving process const VectorBase< R > & maxObjRealInternal() const returns objective function vector after transformation to a maximization problem; since this is how i... int numRowsRational() const void _updateDecompComplementaryDualProblem(bool origObj) update the dual complementary problem with additional columns and rows bool checkBasisDualFeasibility(VectorBase< R > feasVec) checks the dual feasibility of the current basis bool getSlacksRational(VectorRational &vector) gets the vector of slack values if available; returns true on success const SVectorBase< R > & rowVectorRealInternal(int i) const returns vector of row i, ignoring scaling const VectorBase< R > & lowerRealInternal() const returns lower bound vector void _updateDecompReducedProblemViol(bool allrows) update the reduced problem with additional columns and rows based upon the violated original bounds a... 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-... bool getBasisInverseTimesVecReal(R *rhs, R *sol, bool unscale=true) computes dense solution of basis matrix B * sol = rhs; returns true on success void _syncLPReal(bool time=true) synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP,... void _recomputeRangeTypesRational() recomputes range types from scratch using rational LP int numIterations() const number of iterations since last call to solve const SVectorBase< R > & colVectorRealInternal(int i) const returns vector of col i, ignoring scaling bool setDualNorms(int nnormsRow, int nnormsCol, R *norms) sets steepest edge norms and returns false if that's not possible void _setComplementaryDualOriginalObjective() updating the complementary dual problem with the original objective function void addRowsReal(const LPRowSetBase< R > &lprowset) adds multiple rows void changeBoundsReal(int i, const R &lower, const R &upper) changes bounds of column i to lower and upper bool getPrimalRayReal(R *vector, int dim) bool parseSettingsString(char *str) parses one setting string and returns true on success; note that string is modified int numNonzerosRational() const const SVectorRational & rowVectorRational(int i) const returns vector of row i void writeStateReal(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const bool cpxFormat=false) const writes internal LP, basis information, and parameter settings; if rowNames and colNames are NULL,... void changeColReal(int i, const LPColReal &lpcol) replaces column i with lpcol DataArray< SPxRowId > _decompCompPrimalRowIDs Definition soplex.h:1862 void changeObjRational(int i, const Rational &obj) changes objective coefficient of column i to obj void _changeBoundsReal(int i, const R &lower, const R &upper) changes bounds of column i to lower and upper and adjusts basis DataArray< SPxColId > _decompVarBoundDualIDs Definition soplex.h:1854 bool readFile(const char *filename, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) reads LP file in LP or MPS format according to READMODE parameter; gets row names,... 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... void printStatus(std::ostream &os, typename SPxSolverBase< R >::Status status) prints status void changeRhsRational(const mpq_t *rhs, int rhsSize) changes right-hand side vector to rhs (GMP only method) void getBasis(typename SPxSolverBase< R >::VarStatus rows[], typename SPxSolverBase< R >::VarStatus cols[]) const gets current basis via arrays of statuses void _syncRealSolution() synchronizes rational solution with real solution, i.e., copies (rounded) rational solution to real s... int numColsRational() const void _changeLhsReal(const VectorBase< R > &lhs) changes left-hand side vector for constraints to lhs and adjusts basis bool boolParam(const BoolParam param) const returns boolean parameter value const Rational & lowerRational(int i) const returns lower bound of column i int dmaxSizeDualRational(const int base=2) get size of largest denominator in dual solution void addColsRational(const LPColSetRational &lpcolset) adds multiple columns DataArray< SPxRowId > _decompPrimalRowIDs Definition soplex.h:1844 bool writeFileRational(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *intvars=0) const void changeElementReal(int i, int j, const R &val) changes matrix entry in row i and column j to val DataArray< SPxColId > _decompCompPrimalVarBoundIDs Definition soplex.h:1859 void changeRangeReal(int i, const R &lhs, const R &rhs) changes left- and right-hand side of row i void getColRational(int i, LPColRational &lpcol) const gets column i void _removeComplementaryDualFixedPrimalVars(int *currFixedVars) removing the dual columns related to the fixed variables int numColsReal() const void _findViolatedRows(R compObjValue, Array< RowViolation > &violatedrows, int &nviolatedrows) builds the update rows with those violated in the complmentary problem 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,... void _loadRealLP(bool initBasis) load original LP and possibly setup a slack basis bool getDualFarkasReal(R *vector, int dim) void changeUpperRational(int i, const mpq_t *upper) changes upper bound of column i to upper (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 _changeBoundsReal(const VectorBase< R > &lower, const VectorBase< R > &upper) changes vectors of column bounds to lower and upper and adjusts basis void _completeRangeTypesRational() completes range type arrays after adding columns and/or rows void changeUpperReal(const VectorBase< R > &upper) changes vector of upper bounds to upper bool _readFileReal(const char *filename, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) reads real LP in LP or MPS format from file and returns true on success; gets row names,... DataArray< typename SPxSolverBase< R >::VarStatus > _basisStatusCols Definition soplex.h:1923 void _transformFeasibility() transforms LP to feasibility problem by removing the objective function, shifting variables,... 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 t... void _getZeroDualMultiplierIndices(VectorBase< R > feasVector, int *nonposind, int *colsforremoval, int *nnonposind, bool &stop) identifies the columns of the row-form basis that correspond to rows with zero dual multipliers. bool getPrimalRational(VectorRational &vector) int totalSizeDualRational(const int base=2) get size of dual solution void getOriginalProblemStatistics() stores the problem statistics of the original problem int dlcmSizeDualRational(const int base=2) get size of least common multiple of denominators in dual solution bool getRedCostViolation(R &maxviol, R &sumviol) gets violation of reduced costs; returns true on success void addColRational(const LPColRational &lpcol) adds a single column void removeColsRational(int idx[], int n, int perm[]=0) remove all columns with indices in array idx of size n; an array perm of size numColsRational() may b... DataArray< typename SPxSolverBase< R >::VarStatus > _storedBasisStatusCols Definition soplex.h:1731 void _updateDecompComplementaryPrimalProblem(bool origObj) update the primal complementary problem with additional columns and rows void _evaluateSolutionDecomp(SPxSolverBase< R > &solver, SLUFactor< R > &sluFactor, typename SPxSimplifier< R >::Result result) evaluates the solution of the reduced problem for the DBDS bool ignoreUnscaledViolations() sets the status to OPTIMAL in case the LP has been solved with unscaled violations Definition soplex.h:642 bool getDualFarkas(VectorBase< R > &vector) gets the Farkas proof if available; returns true on success bool getDualFarkasRational(mpq_t *vector, const int size) gets the Farkas proof if LP is infeasible; returns true on success (GMP only method) bool _lowerFinite(const RangeType &rangeType) const checks whether RangeType corresponds to finite lower bound void changeObjReal(int i, const R &obj) changes objective coefficient of column i to obj void setRandomSeed(unsigned int seed) set the random seeds of the solver instance void _computeInfeasBox(SolRational &sol, bool transformed) bool writeBasisFile(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const bool cpxFormat=false) const writes basis information to filename; if rowNames and colNames are NULL, default names are used; retu... void _computeReducedProbObjCoeff(bool &stop) computes the reduced problem objective coefficients void _checkOriginalProblemOptimality(VectorBase< R > primalVector, bool printViol) checking the optimality of the original problem. void changeBoundsRational(const VectorRational &lower, const VectorRational &upper) changes vectors of column bounds to lower and upper void _untransformEquality(SolRational &sol) undoes transformation to equality form bool writeDualFileReal(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *intvars=0) const writes the dual of the real LP to file; LP or MPS format is chosen from the extension in filename; if... bool writeFile(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *intvars=0, const bool unscale=true) const Templated write function Real writes real LP to file; LP or MPS format is chosen from the extension i... const char * getRatiotesterName() name of currently loaded ratiotester Rational objValueRational() returns the objective value if a primal solution is available Real realParam(const RealParam param) const returns real parameter value int totalSizePrimalRational(const int base=2) get size of primal solution bool getBoundViolation(R &maxviol, R &sumviol) gets violation of bounds; returns true on success bool getBoundViolationRational(Rational &maxviol, Rational &sumviol) void removeColsReal(int idx[], int n, int perm[]=0) remove all columns with indices in array idx of size n; an array perm of size numColsReal() may be pa... 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 changeObjRational(int i, const mpq_t *obj) changes objective coefficient of column i to obj (GMP only method) bool _upperFinite(const RangeType &rangeType) const checks whether RangeType corresponds to finite upper bound bool saveSettingsFile(const char *filename, const bool onlyChanged=false, int solvemode=1) const writes settings file; returns true on success void changeRhsRational(int i, const Rational &rhs) changes right-hand side of row i to rhs void _getRowsForRemovalComplementaryProblem(int *nonposind, int *bind, int *rowsforremoval, int *nrowsforremoval, int nnonposind) computes the rows to remove from the complementary problem void _changeRangeReal(const VectorBase< R > &lhs, const VectorBase< R > &rhs) changes left- and right-hand side vectors and adjusts basis void _transformUnbounded() transforms LP to unboundedness problem by moving the objective function to the constraints,... void setBasis(const typename SPxSolverBase< R >::VarStatus rows[], const typename SPxSolverBase< R >::VarStatus cols[]) sets starting basis via arrays of statuses void _changeLowerReal(const VectorBase< R > &lower) changes vector of lower bounds to lower and adjusts basis void _solveDecompositionDualSimplex() solves LP using the decomposition based dual simplex void _changeUpperReal(const VectorBase< R > &upper) changes vector of upper bounds to upper and adjusts basis void _formDecompComplementaryProblem() forms the complementary problem int dlcmSizePrimalRational(const int base=2) get size of least common multiple of denominators in primal solution void _computeBasisInverseRational() computes rational inverse of basis matrix as defined by _rationalLUSolverBind void _updateComplementaryPrimalSlackColCoeff() updating the slack column coefficients to adjust for equality constraints @ SCALER_GEOEQUI geometric mean scaling (max 8 rounds) followed by equilibrium scaling (rows and columns) Definition soplex.h:1200 void _performUnboundedIRStable(SolRational &sol, bool &hasUnboundedRay, bool &stoppedTime, bool &stoppedIter, bool &error) performs iterative refinement on the auxiliary problem for testing unboundedness bool getPrimal(VectorBase< R > &vector) gets the primal solution vector if available; returns true on success bool readBasisFile(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0) reads basis information from filename and returns true on success; if rowNames and colNames are NULL,... unsigned int randomSeed() const returns the current random seed of the solver instance void getOriginalProblemBasisColStatus(int &nNonBasicCols) function to retrieve the column status for the original problem basis from the reduced and complement... bool getExactCondition(R &condition) computes the exact condition number for the current basis matrix using the power method; returns true... int numRowsReal() const void _changeUpperReal(int i, const R &upper) changes i 'th upper bound to upper and adjusts basis void changeLowerRational(const VectorRational &lower) changes vector of lower bounds to lower void changeRowReal(int i, const LPRowBase< R > &lprow) replaces row i with lprow void _recomputeRangeTypesReal() recomputes range types from scratch using real LP bool getBasisInverseColRational(const int c, SSVectorRational &vec) computes column c of basis inverse; performs rational factorization if not available; returns true on... void _checkScaling(SPxLPBase< R > *origLP) const check scaling of LP SPxDefaultRT< R > _ratiotesterTextbook Definition soplex.h:1679 void _writeOriginalProblemBasis(const char *filename, NameSet *rowNames, NameSet *colNames, bool cpxFormat) function to build a basis for the original problem as given by the solution to the reduced problem DataArray< SPxColId > _decompDualColIDs Definition soplex.h:1851 SPxSolverBase< R >::VarStatus basisRowStatus(int row) const returns basis status for a single row void _restoreLPReal() restores objective, bounds, and sides of real LP bool setBoolParam(const BoolParam param, const bool value, const bool init=true) sets boolean parameter value; returns true on success void changeLowerReal(const VectorBase< R > &lower) changes vector of lower bounds to lower void printSolutionStatistics(std::ostream &os) prints solution statistics void changeUpperReal(int i, const R &upper) changes i 'th upper bound to upper const Rational & maxObjRational(int i) const returns objective value of column i after transformation to a maximization problem; since this is how... void printShortStatistics(std::ostream &os) prints short statistics const Rational & lhsRational(int i) const returns left-hand side of row i int dmaxSizePrimalRational(const int base=2) get size of largest denominator in primal solution void changeUpperRational(int i, const Rational &upper) changes i 'th upper bound to upper void _updateComplementaryPrimalFixedPrimalVars(int *currFixedVars) updating the dual columns related to the fixed primal variables. bool getRedCost(VectorBase< R > &vector) gets the vector of reduced cost values if available; returns true on success SPxBoundFlippingRT< R > _ratiotesterBoundFlipping Definition soplex.h:1682 bool getRedCostReal(R *vector, int dim) void _syncLPRational(bool time=true) synchronizes rational LP with real LP, i.e., copies real LP to rational LP, without looking at the sy... 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 const SVectorRational & colVectorRational(int i) const returns vector of column i bool getDecompBoundViolation(R &maxviol, R &sumviol) gets violation of bounds; returns true on success void _syncRationalSolution() synchronizes real solution with rational solution, i.e., copies real solution to rational solution void _changeLhsReal(int i, const R &lhs) changes left-hand side of row i to lhs and adjusts basis 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 _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 mem... void changeBoundsRational(int i, const Rational &lower, const Rational &upper) changes bounds of column i to lower and upper RangeType _switchRangeType(const RangeType &rangeType) const switches RANGETYPE_LOWER to RANGETYPE_UPPER and vice versa 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 DataArray< SPxColId > _decompReducedProbColIDs Definition soplex.h:1843 @ ALGORITHM_PRIMAL primal simplex algorithm, i.e., entering for column and leaving for row representation Definition soplex.h:1124 @ ALGORITHM_DUAL dual simplex algorithm, i.e., leaving for column and entering for row representation Definition soplex.h:1127 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 void syncLPReal() synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP,... bool getDecompRowViolation(R &maxviol, R &sumviol) gets violation of constraints; returns true on success void _transformEquality() introduces slack variables to transform inequality constraints into equations for both rational and r... DataArray< int > _rationalLUSolverBind Definition soplex.h:1711 bool decompTerminate(R timeLimit) function call to terminate the decomposition simplex DualSign getExpectedDualVariableSign(int rowNumber) returns the expected sign of the dual variables for the reduced problem std::string statisticString() const statistical information in form of a string void _ensureRationalLP() ensures that the rational LP is available; performs no sync DataArray< SPxColId > _decompCompPrimalColIDs Definition soplex.h:1864 void _getCompatibleBoundCons(LPRowSetBase< R > &boundcons, int *compatboundcons, int *nonposind, int *ncompatboundcons, int nnonposind, bool &stop) computes the compatible bound constraints and adds them to the reduced problem void changeBoundsReal(const VectorBase< R > &lower, const VectorBase< R > &upper) changes vectors of column bounds to lower and upper int getOrigVarFixedDirection(int colNum) determining which bound the primal variables will be fixed to. 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 _identifyComplementaryDualFixedPrimalVars(int *currFixedVars) removing the dual columns related to the fixed variables void getNdualNorms(int &nnormsRow, int &nnormsCol) const gets number of available dual norms void removeColRangeRational(int start, int end, int perm[]=0) removes columns start to end including both; an array perm of size numColsRational() may be passed as... void changeLhsRational(const VectorRational &lhs) changes left-hand side vector for constraints to lhs void changeRowRational(int i, const LPRowRational &lprow) replaces row i with lprow void _addRowReal(const LPRowBase< R > &lprow) adds a single row to the real LP and adjusts basis void removeColRangeReal(int start, int end, int perm[]=0) removes columns start to end including both; an array perm of size numColsReal() may be passed as buf... void getUpperReal(VectorBase< R > &upper) const gets upper bound vector void _createDecompReducedAndComplementaryProblems() creating copies of the original problem that will be manipulated to form the reduced and complementar... DataArray< SPxColId > _decompCompPrimalFixedVarIDs Definition soplex.h:1857 SoPlexBase< R > & operator=(const SoPlexBase< R > &rhs) assignment operator const VectorRational & maxObjRational() const returns objective function vector after transformation to a maximization problem; since this is how i... void removeRowsReal(int idx[], int n, int perm[]=0) remove all rows with indices in array idx of size n; an array perm of size numRows() may be passed as... bool getDual(VectorBase< R > &vector) gets the dual solution vector if available; returns true on success void resetSettings(const bool quiet=false, const bool init=true) resets default parameter settings DataArray< SPxColId > _decompFixedVarDualIDs Definition soplex.h:1852 void removeRowsRational(int idx[], int n, int perm[]=0) remove all rows with indices in array idx of size n; an array perm of size numRowsRational() may be p... void changeObjReal(const VectorBase< R > &obj) changes objective function vector to obj Rational maxAbsNonzeroRational() const returns biggest non-zero element in absolute value @ POLISHING_FRACTIONALITY minimize number of basic slack variables, i.e. more variables between bounds Definition soplex.h:1342 @ POLISHING_INTEGRALITY maximize number of basic slack variables, i.e. more variables on bounds Definition soplex.h:1339 Array< UnitVectorRational * > _unitMatrixRational Definition soplex.h:1732 DataArray< SPxRowId > _decompReducedProbRowIDs Definition soplex.h:1839 @ RATIOTESTER_BOUNDFLIPPING bound flipping ratio test for long steps in the dual simplex Definition soplex.h:1254 R maxObjReal(int i) const returns objective value of column i after transformation to a maximization problem; since this is how... void _unscaleSolutionReal(SPxLPBase< R > &LP, bool persistent=true) unscales stored solution to remove internal or external scaling of LP bool _reapplyPersistentScaling() const check whether persistent scaling is supposed to be reapplied again after unscaling void removeRowsReal(int perm[]) removes all rows with an index i such that perm[i] < 0; upon completion, perm[i] >= 0 indicates the n... void _changeRhsReal(const VectorBase< R > &rhs) changes right-hand side vector to rhs and adjusts basis const VectorBase< R > & rhsRealInternal() const returns right-hand side vector, ignoring scaling void changeLowerRational(int i, const mpq_t *lower) changes lower bound of column i to lower (GMP only method) void _removeRowsReal(int perm[]) removes all rows with an index i such that perm[i] < 0; upon completion, perm[i] >= 0 indicates the n... R getCompSlackVarCoeff(int primalRowNum) gets the coefficient of the slack variable in the primal complementary problem void _addRowReal(R lhs, const SVectorBase< R > &lprow, R rhs) adds a single row to the real LP and adjusts basis bool getBasisInverseRowRational(const int r, SSVectorRational &vec) computes row r of basis inverse; performs rational factorization if not available; returns true on su... void _solveRealLPAndRecordStatistics(volatile bool *interrupt=NULL) call floating-point solver and update statistics on iterations etc. bool getPrimalRayRational(mpq_t *vector, const int size) gets the primal ray if LP is unbounded; returns true on success (GMP only method) bool getPrimalRayRational(VectorRational &vector) Statistics * _statistics statistics since last call to solveReal() or solveRational() Definition soplex.h:1638 void syncLPRational() synchronizes rational LP with real LP, i.e., copies real LP to rational LP, if sync mode is manual void getColVectorReal(int i, DSVectorBase< R > &col) const gets vector of col i bool hasDualFarkas() const is Farkas proof of infeasibility available? void _changeRangeReal(int i, const R &lhs, const R &rhs) changes left- and right-hand side of row i and adjusts basis void getColsRational(int start, int end, LPColSetRational &lpcolset) const gets columns start, ..., end bool setSettings(const Settings &newSettings, const bool init=true) sets parameter settings; returns true on success void _decompResolveWithoutPreprocessing(SPxSolverBase< R > &solver, SLUFactor< R > &sluFactor, typename SPxSimplifier< R >::Result result) loads original problem into solver and solves again after it has been solved to optimality with prepr... void _decompSimplifyAndSolve(SPxSolverBase< R > &solver, SLUFactor< R > &sluFactor, bool fromScratch, bool applyPreprocessing) simplifies the problem and solves bool getRedCostRational(mpq_t *vector, const int size) gets the vector of reduced cost values if available; returns true on success (GMP only method) void _addColsReal(const LPColSetReal &lpcolset) adds multiple columns to the real LP and adjusts basis void _changeRhsReal(int i, const R &rhs) changes right-hand side of row i to rhs and adjusts basis void printOriginalProblemStatistics(std::ostream &os) stores the problem statistics of the original problem void getRowVectorReal(int i, DSVectorBase< R > &row) const gets vector of row i void changeLhsReal(int i, const R &lhs) changes left-hand side of row i to lhs void removeRowsRational(int perm[]) removes all rows with an index i such that perm[i] < 0; upon completion, perm[i] >= 0 indicates the n... void getOriginalProblemBasisRowStatus(DataArray< int > °enerateRowNums, DataArray< typename SPxSolverBase< R >::VarStatus > °enerateRowStatus, int &nDegenerateRows, int &nNonBasicRows) function to retrieve the original problem row basis status from the reduced and complementary problem... bool getBasisInverseRowReal(int r, R *coef, int *inds=NULL, int *ninds=NULL, bool unscale=true) computes row r of basis inverse; returns true on success @ SOLVEMODE_AUTO decide depending on tolerances whether to apply iterative refinement Definition soplex.h:1287 bool getBasisInverseColReal(int c, R *coef, int *inds=NULL, int *ninds=NULL, bool unscale=true) computes column c of basis inverse; returns true on success LPRowBase< R >::Type rowTypeReal(int i) const returns inequality type of row i void _optimizeRational(volatile bool *interrupt=NULL) temporary fix for Rational const VectorRational & lhsRational() const returns left-hand side vector void changeObjRational(const VectorRational &obj) changes objective function vector to obj SPxSolverBase< R >::Status status() const returns the current solver status bool getDualFarkasRational(VectorRational &vector) R maxAbsNonzeroReal() const returns biggest non-zero element in absolute value SPxBasisBase< R >::SPxStatus basisStatus() const returns the current basis status bool isPrimalFeasible() const is stored primal solution feasible? void getLowerReal(VectorBase< R > &lower) const gets lower bound vector void _performFeasIRStable(SolRational &sol, bool &withDualFarkas, bool &stoppedTime, bool &stoppedIter, bool &error) performs iterative refinement on the auxiliary problem for testing feasibility RangeType _rangeTypeReal(const R &lower, const R &upper) const determines RangeType from real bounds bool getPrimalReal(R *p_vector, int size) bool getDualRational(VectorRational &vector) void _untransformUnbounded(SolRational &sol, bool unbounded) undoes transformation to unboundedness problem void _verifySolutionReal() verify computed solution and resolve if necessary void removeColsReal(int perm[]) removes all columns with an index i such that perm[i] < 0; upon completion, perm[i] >= 0 indicates th... DataArray< SPxRowId > _decompDualRowIDs Definition soplex.h:1849 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 changeLowerReal(int i, const R &lower) changes lower bound of column i to lower void _evaluateSolutionReal(typename SPxSimplifier< R >::Result simplificationStatus) checks result of the solving process and solves again without preprocessing if necessary bool setRealParam(const RealParam param, const Real value, const bool init=true) sets real parameter value; returns true on success const VectorRational & lowerRational() const returns lower bound vector 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 buf... void _changeElementReal(int i, int j, const R &val) changes matrix entry in row i and column j to val and adjusts basis void _removeColsReal(int perm[]) removes all columns with an index i such that perm[i] < 0; upon completion, perm[i] >= 0 indicates th... SPxSolverBase< R >::VarStatus basisColStatus(int col) const returns basis status for a single column Rational minAbsNonzeroRational() const returns smallest non-zero element in absolute value bool setIntParam(const IntParam param, const int value, const bool init=true) sets integer parameter value; returns true on success void _deleteAndUpdateRowsComplementaryProblem(SPxRowId rangedRowIds[], int &naddedrows) removing rows from the complementary problem. bool getDualReal(R *p_vector, int dim) void getRowsRational(int start, int end, LPRowSetRational &lprowset) const gets rows start, ..., end. bool getDualViolationRational(Rational &maxviol, Rational &sumviol) void _addRowsReal(const LPRowSetBase< R > &lprowset) adds multiple rows to the real LP and adjusts basis SPxSolverBase< R >::Status solve(volatile bool *interrupt=NULL) Definition soplex.h:606 void addColsReal(const LPColSetBase< R > &lpcolset) adds multiple columns void changeRhsReal(const VectorBase< R > &rhs) changes right-hand side vector to rhs const VectorRational & rhsRational() const returns right-hand side vector void changeRangeReal(const VectorBase< R > &lhs, const VectorBase< R > &rhs) changes left- and right-hand side vectors 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 _updateDecompReducedProblem(R objVal, VectorBase< R > dualVector, VectorBase< R > redcostVector, VectorBase< R > compPrimalVector, VectorBase< R > compDualVector) update the reduced problem with additional columns and rows bool computeBasisInverseRational() compute rational basis inverse; returns true on success void removeRowRangeReal(int start, int end, int perm[]=0) removes rows start to end including both; an array perm of size numRows() may be passed as buffer mem... @ REPRESENTATION_AUTO automatic choice according to number of rows and columns Definition soplex.h:1111 @ REPRESENTATION_COLUMN column representation Ax - s = 0, lower <= x <= upper, lhs <= s <= rhs Definition soplex.h:1114 bool loadSettingsFile(const char *filename) reads settings file; returns true on success void _storeSolutionRealFromPresol() stores solution from the simplifier because problem vanished in presolving step 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) bool multBasis(R *vec, bool unscale=true) multiply with basis matrix; B * vec (inplace) bool _reconstructSolutionRational(SolRational &sol, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusRows, DataArray< typename SPxSolverBase< R >::VarStatus > &basisStatusCols, const Rational &denomBoundSquared) attempts rational reconstruction of primal-dual solution void _changeLowerReal(int i, const R &lower) changes lower bound of column i to lower and adjusts basis void changeRangeRational(const VectorRational &lhs, const VectorRational &rhs) changes left- and right-hand side vectors void _addColReal(R obj, R lower, const SVectorBase< R > &lpcol, R upper) adds a single column to the real LP and adjusts basis void changeLhsRational(int i, const Rational &lhs) changes left-hand side of row i to lhs void setIntegralityInformation(int ncols, int *intInfo) pass integrality information about the variables to the solver bool writeFileReal(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *intvars=0, const bool unscale=true) const 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) DataArray< SPxRowId > _decompReducedProbColRowIDs Definition soplex.h:1841 bool getPrimalRational(mpq_t *vector, const int size) gets the primal solution vector if available; returns true on success (GMP only method) void _disableSimplifierAndScaler() disables simplifier and scaler R minAbsNonzeroReal() const returns smallest non-zero element in absolute value void getObjRational(VectorRational &obj) const gets objective function vector bool getPrimalRay(VectorBase< R > &vector) gets the primal ray if available; returns true on success DualSign getOrigProbDualVariableSign(int rowNumber) returns the expected sign of the dual variables for the original problem const Rational & rhsRational(int i) const returns right-hand side of row i const UnitVectorRational * _unitVectorRational(const int i) returns pointer to a constant unit vector available until destruction of the SoPlexBase class void _changeRowReal(int i, const LPRowBase< R > &lprow) replaces row i with lprow and adjusts basis bool getRedCostRational(VectorRational &vector) void removeRowRangeRational(int start, int end, int perm[]=0) removes rows start to end including both; an array perm of size numRowsRational() may be passed as bu... DataArray< SPxColId > _decompPrimalColIDs Definition soplex.h:1845 const VectorBase< R > & upperRealInternal() const returns upper bound vector bool getRedCostViolationRational(Rational &maxviol, Rational &sumviol) void _getCompatibleColumns(VectorBase< R > feasVector, int *nonposind, int *compatind, int *rowsforremoval, int *colsforremoval, int nnonposind, int *ncompatind, bool formRedProb, bool &stop) retrieves the compatible columns from the constraint matrix void changeRhsReal(int i, const R &rhs) changes right-hand side of row i to rhs void _idxToPerm(int *idx, int idxSize, int *perm, int permSize) const creates a permutation for removing rows/columns from an array of indices void changeRangeRational(int i, const Rational &lhs, const Rational &rhs) changes left- and right-hand side of row i bool _readFileRational(const char *filename, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) reads rational LP in LP or MPS format from file and returns true on success; gets row names,... void _lift() reduces matrix coefficient in absolute value by the lifting procedure of Thiele et al.... void removeColsRational(int perm[]) removes all columns with an index i such that perm[i] < 0; upon completion, perm[i] >= 0 indicates th... const VectorRational & upperRational() const returns upper bound vector void _updateComplementaryDualFixedPrimalVars(int *currFixedVars) updating the dual columns related to the fixed primal variables. @ TESTDUALINF should dual infeasibility be tested in order to try to return a dual solution even if primal infeasib... Definition soplex.h:951 @ ENSURERAY re-optimize the original problem to get a proof (ray) of infeasibility/unboundedness? Definition soplex.h:991 @ ACCEPTCYCLING should cycling solutions be accepted during iterative refinement? Definition soplex.h:970 @ RATFAC should a rational factorization be performed after iterative refinement? Definition soplex.h:954 @ USECOMPDUAL should the dual of the complementary problem be used in the decomposition simplex? Definition soplex.h:964 @ LIFTING should lifting be used to reduce range of nonzero matrix coefficients? Definition soplex.h:945 @ FULLPERTURBATION perturb the entire problem or only the relevant bounds of s single pivot? Definition soplex.h:988 @ USEDECOMPDUALSIMPLEX should the decomposition based dual simplex be used to solve the LP? Setting this to true forces the ... Definition soplex.h:958 @ POWERSCALING round scaling factors for iterative refinement to powers of two? Definition soplex.h:976 @ RATFACJUMP continue iterative refinement with exact basic solution if not optimal? Definition soplex.h:979 @ EXPLICITVIOL should row and bound violations be computed explicitly in the update of reduced problem in the decomp... Definition soplex.h:967 void _formDecompReducedProblem(bool &stop) forms the reduced problem void changeLowerRational(int i, const Rational &lower) changes lower bound of column i to lower SPxSolverBase< R >::Status optimize(volatile bool *interrupt=NULL) optimize the given LP void _checkBasisScaling() check correctness of (un)scaled basis matrix operations void printDecompDisplayLine(SPxSolverBase< R > &solver, const SPxOut::Verbosity origVerb, bool force, bool forceHead) prints a display line of the flying table for the DBDS RangeType _rangeTypeRational(const Rational &lower, const Rational &upper) const determines RangeType from rational bounds void getRhsReal(VectorBase< R > &rhs) const gets right-hand side vector void writeStateRational(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const bool cpxFormat=false) const writes internal LP, basis information, and parameter settings; if rowNames and colNames are NULL,... bool getRowViolationRational(Rational &maxviol, Rational &sumviol) Everything should be within this namespace. Implementation of Sparse Linear Solver. Implementation of Sparse Linear Solver with Rational precision. Types of solution classes. Class for storing a primal-dual solution with basis information. Auto pricer. Bound flipping ratio test (long step dual) for SoPlex. Dantzig pricer. Textbook ratio test for SoPlex. Debugging, floating point type and parameter definitions. Devex pricer. LP equilibrium scaling. Fast shifting ratio test. LP geometric mean scaling. returns the current git hash of SoPlex Harris pricing with shifting. Hybrid pricer. LP least squares scaling. Saving LPs in a form suitable for SoPlex. General methods in LP preprocessing. Partial multiple pricing. Abstract pricer base class. Abstract ratio test base class. LP scaling base class. LP simplification base class. main LP solver class SoPlex start basis generation base class. Steepest edge pricer with exact initialization of weights. Steepest edge pricer. Simple heuristic SPxStarter. Solution vector based start basis. Weighted start basis. R operator()(RowViolation i, RowViolation j) const Definition soplex.h:1787 RowViolationCompare() Definition soplex.h:1780 std::string name[SoPlexBase< R >::BOOLPARAM_COUNT] array of names for boolean parameters Definition soplex.h:1448 std::string description[SoPlexBase< R >::BOOLPARAM_COUNT] array of descriptions for boolean parameters Definition soplex.h:1450 bool defaultValue[SoPlexBase< R >::BOOLPARAM_COUNT] array of default values for boolean parameters Definition soplex.h:1452 std::string name[SoPlexBase< R >::INTPARAM_COUNT] array of names for integer parameters Definition soplex.h:1460 int lower[SoPlexBase< R >::INTPARAM_COUNT] array of lower bounds for int parameter values Definition soplex.h:1466 int upper[SoPlexBase< R >::INTPARAM_COUNT] array of upper bounds for int parameter values Definition soplex.h:1468 int defaultValue[SoPlexBase< R >::INTPARAM_COUNT] array of default values for integer parameters Definition soplex.h:1464 std::string description[SoPlexBase< R >::INTPARAM_COUNT] array of descriptions for integer parameters Definition soplex.h:1462 Real upper[SoPlexBase< R >::REALPARAM_COUNT] array of upper bounds for real parameter values Definition soplex.h:1484 Real defaultValue[SoPlexBase< R >::REALPARAM_COUNT] array of default values for real parameters Definition soplex.h:1480 Real lower[SoPlexBase< R >::REALPARAM_COUNT] array of lower bounds for real parameter values Definition soplex.h:1482 std::string description[SoPlexBase< R >::REALPARAM_COUNT] array of descriptions for real parameters Definition soplex.h:1478 std::string name[SoPlexBase< R >::REALPARAM_COUNT] array of names for real parameters Definition soplex.h:1476
|