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
898 /// reads LP file in LP or MPS format according to READMODE parameter; gets row names, column names, and
905 /// writes real LP to file; LP or MPS format is chosen from the extension in \p filename; if \p rowNames and \p
906 /// colNames are \c nullptr, default names are used; if \p intVars is not \c nullptr, the variables contained in it are
909 /// writes rational LP to file; LP or MPS format is chosen from the extension in \p filename; if \p rowNames and \p
910 /// colNames are \c nullptr, default names are used; if \p intVars is not \c nullptr, the variables contained in it are
927 /// writes the dual of the real LP to file; LP or MPS format is chosen from the extension in \p filename;
928 /// if \p rowNames and \p colNames are \c nullptr, default names are used; if \p intVars is not \c nullptr,
934 /// reads basis information from \p filename and returns true on success; if \p rowNames and \p colNames are \c nullptr,
939 /// writes basis information to \p filename; if \p rowNames and \p colNames are \c nullptr, default names are used;
945 /// writes internal LP, basis information, and parameter settings; if \p rowNames and \p colNames are \c nullptr,
951 /// writes internal LP, basis information, and parameter settings; if \p rowNames and \p colNames are \c nullptr,
1148 };
1161 };
1171 };
1181 };
1203 };
1219 };
1244 };
1260 };
1282 };
1298 };
1311 };
1321 };
1334 };
1347 };
1360 };
1373 };
1386 };
1430 /// lower threshold in lifting (nonzero matrix coefficients with smaller absolute value will be reformulated)
1433 /// upper threshold in lifting (nonzero matrix coefficients with larger absolute value will be reformulated)
1436 /// sparse pricing threshold (\#violations < dimension * SPARSITY_THRESHOLD activates sparse pricing)
1439 /// threshold on number of rows vs. number of columns for switching from column to row representations in auto mode
1448 /// refactor threshold for nonzeros in last factorized basis matrix compared to updated basis matrix
1451 /// refactor threshold for fill-in in current factor update compared to fill-in in last factorization
1608 bool setRationalParam(const RationalParam param, const Rational value, const bool init = true);
1762 bool _boostingLimitReached; // true if BP::default_precision() > max authorized number of digits
1763 bool _switchedToBoosted; // true if _boostedSolver is used instead of _solver to cope with the numerical failure of _solver
1764 // this attribute remembers wether we are testing feasibility (1), unboundedness (2) or neither (0)
1766 // example: if _certificateMode == 1, it is the basis for the feasibility LP that should be stored/loaded.
1774 bool _factorSolNewBasisPrecBoost; // false if the current basis has already been factorized (no new iterations have been done)
1775 int _nextRatrecPrecBoost; // the iteration during or after which rational reconstruction can be performed
1822 bool _isRealLPLoaded; // true indicates that the original LP is loaded in the _solver variable, hence all actions
1907 // these vectors store the last basis met in precision boosting when not testing feasibility or unboundedness.
1921 // When calling setBasis or getBasis (from SPxSolverBase class), a specific conversion is needed.
1927 // mysolver.getBasis(_tmpBasisStatusRows, _tmpBasisStatusCols, _basisStatusRows.size(), _basisStatusCols.size())
2061 /// removes all rows with an index \p i such that \p perm[i] < 0; upon completion, \p perm[i] >= 0 indicates the
2062 /// new index where row \p i has been moved to; note that \p perm must point to an array of size at least
2066 /// remove all rows with indices in array \p idx of size \p n; an array \p perm of size #numRows() may be passed
2070 /// removes rows \p start to \p end including both; an array \p perm of size #numRows() may be passed as buffer
2077 /// removes all columns with an index \p i such that \p perm[i] < 0; upon completion, \p perm[i] >= 0 indicates the
2078 /// new index where column \p i has been moved to; note that \p perm must point to an array of size at least
2082 /// remove all columns with indices in array \p idx of size \p n; an array \p perm of size #numColsReal() may be
2086 /// removes columns \p start to \p end including both; an array \p perm of size #numColsReal() may be passed as
2111 /// reads real LP in LP or MPS format from file and returns true on success; gets row names, column names, and
2113 bool _readFileReal(const char* filename, NameSet* rowNames = nullptr, NameSet* colNames = nullptr,
2116 /// reads rational LP in LP or MPS format from file and returns true on success; gets row names, column names, and
2131 /// synchronizes real LP with rational LP, i.e., copies (rounded) rational LP into real LP, without looking at the sync mode
2134 /// synchronizes rational LP with real LP, i.e., copies real LP to rational LP, without looking at the sync mode
2137 /// synchronizes rational solution with real solution, i.e., copies (rounded) rational solution to real solution
2140 /// synchronizes real solution with rational solution, i.e., copies real solution to rational solution
2143 /// returns pointer to a constant unit vector available until destruction of the SoPlexBase class
2146 /// parses one line in a settings file and returns true on success; note that the string is modified
2155 /// 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
2231 /// computes primal scaling factor; limit increase in scaling by tolerance used in floating point solve
2239 /// computes dual scaling factor; limit increase in scaling by tolerance used in floating point solve
2296 /// updates or recomputes reduced cost values depending on which looks faster; adding one to the length of the
2324 /// setup recovery mecanism using multiprecision, return false if maximum precision reached, true otherwise
2340 // stores given basis in old basis attributes: _oldBasisStatusRows, _oldFeasBasisStatusRows, _oldUnbdBasisStatusRows (and ...Cols)
2344 // stores given basis in old basis attributes: _oldBasisStatusRows, _oldFeasBasisStatusRows, _oldUnbdBasisStatusRows (and ...Cols)
2348 // get the last advanced and stable basis stored by the initial solver and store it as old basis, unsimplify basis if simplifier activated
2351 // get the last advanced and stable basis stored by the boosted solver and store it as old basis, unsimplify basis if simplifier activated
2354 // load old basis in solver. The old basis loaded depends on the certificate mode (feasibility, unboundedness, or neither)
2373 /// solves current problem with iterative refinement and recovery mechanism using boosted solver
2435 /// reduces matrix coefficient in absolute value by the lifting procedure of Thiele et al. 2013
2453 /// introduces slack variables to transform inequality constraints into equations for both rational and real LP,
2460 /// transforms LP to unboundedness problem by moving the objective function to the constraints, changing right-hand
2461 /// side and bounds to zero, and adding an auxiliary variable for the decrease in the objective function
2467 /// transforms LP to feasibility problem by removing the objective function, shifting variables, and homogenizing the
2476 Given constraints of the form \f$ lhs <= Ax <= rhs \f$, a farkas proof y should satisfy \f$ y^T A = 0 \f$ and
2477 \f$ y_+^T lhs - y_-^T rhs > 0 \f$, where \f$ y_+, y_- \f$ denote the positive and negative parts of \f$ y \f$.
2478 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
2485 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
2486 bounds on \f$ x \f$ imply that all feasible \f$ x \f$ satisfy (*), and if not then compute bounds on \f$ x \f$ to
2495 \f$ B \f$ can be increased by iteratively including variable bounds smaller than \f$ B \f$. The speed of this
2496 method can be further improved by using interval arithmetic for all computations. For related information see
2504 typename SPxSolverBase<R>::Status _solveRealForRational(bool fromscratch, VectorBase<R>& primal,
2510 typename SPxSolverBase<R>::Status _solveRealStable(bool acceptUnbounded, bool acceptInfeasible,
2554 /// loads original problem into solver and solves again after it has been solved to optimality with preprocessing
Collection of dense, sparse, and semi-sparse vectors. Definition rational.h:237 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 spxsolver.h:70 Wrapper for several output streams. A verbosity level is used to decide which stream to use and wheth... Definition spxout.h:78 int _intParamValues[SoPlexBase< R >::INTPARAM_COUNT] array of current integer parameter values Definition soplex.h:1555 static struct soplex::SoPlexBase::Settings::BoolParam boolParam bool _boolParamValues[SoPlexBase< R >::BOOLPARAM_COUNT] array of current boolean parameter values Definition soplex.h:1552 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:1558 static struct soplex::SoPlexBase::Settings::RealParam realParam Definition soplex.h:121 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 bool getBasisInverseTimesVecRational(const SVectorRational &rhs, SSVectorRational &sol) computes solution of basis matrix B * sol = rhs; performs rational factorization if not available; re... bool _isSolveStopped(bool &stoppedTime, bool &stoppedIter) const should solving process be stopped? SPxLeastSqSC< BP > _boostedScalerLeastsq Definition soplex.h:1815 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 _untransformFeasibility(SolRational &sol, bool infeasible) undoes transformation to feasibility problem void _computeDualViolation(SolRational &sol, Rational &dualViolation, const bool &maximizing) computes dual violation during the refinement loop bool getRowViolation(R &maxviol, R &sumviol) gets violation of constraints; returns true on success 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... bool _setupBoostedSolverAfterRecovery() setup recovery mecanism using multiprecision, return false if maximum precision reached,... 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 _updateBoostingStatistics() 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 v... 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 _isBoostedConsistent() const checks consistency for the boosted solver bool getSlacksReal(VectorBase< R > &vector) gets the vector of slack values if available; returns true on success DataArray< typename SPxSolverBase< BP >::VarStatus > _tmpBasisStatusRows Definition soplex.h:1928 SPxDantzigPR< BP > _boostedPricerDantzig Definition soplex.h:1796 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:1425 @ PRECISION_BOOSTING_FACTOR factor by which the precision of the floating-point solver is multiplied Definition soplex.h:1470 @ SPARSITY_THRESHOLD sparse pricing threshold (#violations < dimension * SPARSITY_THRESHOLD activates sparse pricing) Definition soplex.h:1437 @ LIFTMAXVAL upper threshold in lifting (nonzero matrix coefficients with larger absolute value will be reformulat... Definition soplex.h:1434 @ FPFEASTOL working tolerance for feasibility in floating-point solver during iterative refinement Definition soplex.h:1422 @ LIFTMINVAL lower threshold in lifting (nonzero matrix coefficients with smaller absolute value will be reformula... Definition soplex.h:1431 @ REPRESENTATION_SWITCH threshold on number of rows vs. number of columns for switching from column to row representations in... Definition soplex.h:1440 @ REFAC_UPDATE_FILL refactor threshold for fill-in in current factor update compared to fill-in in last factorization Definition soplex.h:1452 @ MINRED minimal reduction (sum of removed rows/cols) to continue simplification Definition soplex.h:1446 @ MIN_MARKOWITZ minimal Markowitz threshold to control sparsity/stability in LU factorization Definition soplex.h:1464 @ REFAC_MEM_FACTOR refactor threshold for memory growth in factorization since last refactorization Definition soplex.h:1455 @ SIMPLIFIER_MODIFYROWFAC minimal modification threshold to apply presolve reductions Definition soplex.h:1467 @ REFAC_BASIS_NNZ refactor threshold for nonzeros in last factorized basis matrix compared to updated basis matrix Definition soplex.h:1449 @ LEASTSQ_ACRCY accuracy of conjugate gradient method in least squares scaling (higher value leads to more iterations... Definition soplex.h:1458 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 _verifyObjLimitReal() verify computed obj stop and resolve if necessary bool getSlacksReal(R *p_vector, int dim) DataArray< typename SPxSolverBase< R >::VarStatus > _basisStatusRows Definition soplex.h:1899 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 @ LEASTSQ_MAXROUNDS maximum number of conjugate gradient iterations in least square scaling Definition soplex.h:1118 @ REPRESENTATION type of computational form, i.e., column or row representation Definition soplex.h:1055 @ RATFAC_MINSTALLS minimum number of stalling refinements since last pivot to trigger rational factorization Definition soplex.h:1115 void changeUpperRational(const VectorRational &upper) changes vector of upper bounds to upper void _convertDataArrayVarStatusToRPrecision(DataArray< typename SPxSolverBase< BP >::VarStatus > &base, DataArray< typename SPxSolverBase< R >::VarStatus > ©) 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:1861 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 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) 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 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... 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 o... int numRowsRational() const bool checkBasisDualFeasibility(VectorBase< R > feasVec) checks the dual feasibility of the current basis void _updateSlacks(SolRational &sol, int &primalSize) updates or recomputes slacks depending on which looks faster 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 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 _applyScaledObj(SPxSolverBase< T > &solver, Rational &dualScale, SolRational &sol) applies scaled objective function 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 bool _factorSolNewBasisPrecBoost Definition soplex.h:1774 @ ALGORITHM_PRIMAL primal simplex algorithm, i.e., entering for column and leaving for row representation Definition soplex.h:1167 @ ALGORITHM_DUAL dual simplex algorithm, i.e., leaving for column and entering for row representation Definition soplex.h:1170 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) 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 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 changeColReal(int i, const LPColReal &lpcol) replaces column i with lpcol 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 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... SPxHarrisRT< BP > _boostedRatiotesterHarris Definition soplex.h:1803 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) 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 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 bool _inUnbdMode() void addColsRational(const LPColSetRational &lpcolset) adds multiple columns void changeElementReal(int i, int j, const R &val) changes matrix entry in row i and column j to val 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 bool _loadBasisFromOldBasis(bool boosted) 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 _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 int numColsReal() const 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 const std::shared_ptr< Tolerances > tolerances() const returns current tolerances 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 _solveRealLPAndRecordStatistics(volatile bool *interrupt=nullptr) call floating-point solver and update statistics on iterations etc. 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 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 bu... void _optimizeRational(volatile bool *interrupt=nullptr) temporary fix for Rational DataArray< typename SPxSolverBase< R >::VarStatus > _basisStatusCols Definition soplex.h:1900 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 _optimize(volatile bool *interrupt=nullptr) solves the templated LP SPxParMultPR< BP > _boostedPricerParMult Definition soplex.h:1797 bool getPrimalRational(VectorRational &vector) int totalSizeDualRational(const int base=2) get size of dual solution 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 SPxSolverBase< R >::Status optimize(volatile bool *interrupt=nullptr) optimize the given LP SPxSolverBase< R >::Status solve(volatile bool *interrupt=nullptr) Definition soplex.h:606 void addColRational(const LPColRational &lpcol) adds a single column DataArray< typename SPxSolverBase< R >::VarStatus > _storedBasisStatusCols Definition soplex.h:1862 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 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 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 nullp... void _applyScaledBounds(SPxSolverBase< T > &solver, Rational &primalScale) applies scaled bounds bool _lowerFinite(const RangeType &rangeType) const checks whether RangeType corresponds to finite lower bound void _checkRefinementProgress(Rational &boundsViolation, Rational &sideViolation, Rational &redCostViolation, Rational &dualViolation, Rational &maxViolation, Rational &bestViolation, const Rational &violationImprovementFactor, int &numFailedRefinements) checks refinement loop progress void changeObjReal(int i, const R &obj) changes objective coefficient of column i to obj 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,... void setRandomSeed(unsigned int seed) set the random seeds of the solver instance void _computeInfeasBox(SolRational &sol, bool transformed) 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,... void _applyScaledSides(SPxSolverBase< T > &solver, Rational &primalScale) applies scaled sides 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 void _switchToFeasMode() 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... const char * getRatiotesterName() name of currently loaded ratiotester Rational objValueRational() returns the objective value if a primal solution is available 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 Real realParam(const RealParam param) const returns real parameter value int totalSizePrimalRational(const int base=2) get size of primal solution @ REPRESENTATION_AUTO automatic choice according to number of rows and columns Definition soplex.h:1154 @ REPRESENTATION_COLUMN column representation Ax - s = 0, lower <= x <= upper, lhs <= s <= rhs Definition soplex.h:1157 bool getBoundViolation(R &maxviol, R &sumviol) gets violation of bounds; returns true on success bool getBoundViolationRational(Rational &maxviol, Rational &sumviol) 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 SPxEquiliSC< BP > _boostedScalerBiequi Definition soplex.h:1811 void changeRhsRational(int i, const Rational &rhs) changes right-hand side of row i to rhs void _convertDataArrayVarStatusToBoosted(DataArray< typename SPxSolverBase< R >::VarStatus > &base, DataArray< typename SPxSolverBase< BP >::VarStatus > ©) SPxBoundFlippingRT< BP > _boostedRatiotesterBoundFlipping Definition soplex.h:1805 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 p... 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 _forceNonbasicToBound(SolRational &sol, int &c, const int &maxDimRational, bool toLower) forces value of given nonbasic variable to bound 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 _changeUpperReal(const VectorBase< R > &upper) changes vector of upper bounds to upper and adjusts basis 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 _computeSidesViolation(SolRational &sol, Rational &sideViolation) computes violation of sides during the refinement loop @ SOLVEMODE_AUTO decide depending on tolerances whether to apply iterative refinement Definition soplex.h:1330 DataArray< typename SPxSolverBase< R >::VarStatus > _oldFeasBasisStatusRows Definition soplex.h:1912 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 _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,... void _switchToBoosted() disable initial precision solver and switch to boosted solver Presol< BP > _boostedSimplifierPaPILO Definition soplex.h:1818 unsigned int randomSeed() const returns the current random seed of the solver instance bool getExactCondition(R &condition) computes the exact condition number for the current basis matrix using the power method; returns true... 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,... Real _tolPrecisionRatio ratios for computing the tolerances for precision boosting ratio denotes the proportion of precision ... Definition soplex.h:1785 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 @ RATIOTESTER_BOUNDFLIPPING bound flipping ratio test for long steps in the dual simplex Definition soplex.h:1297 void _solveBoostedRealLPAndRecordStatistics(volatile bool *interrupt=nullptr) call floating-point solver and update statistics on iterations etc. void changeRowReal(int i, const LPRowBase< R > &lprow) replaces row i with lprow void _recomputeRangeTypesReal() recomputes range types from scratch using real LP int numIterationsBoosted() const number of iterations in higher precision since last call to solve 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 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 itera... SPxDefaultRT< R > _ratiotesterTextbook Definition soplex.h:1730 void _storeLastStableBasisBoosted(bool vanished) SPxSolverBase< R >::VarStatus basisRowStatus(int row) const returns basis status for a single row void _restoreLPReal() restores objective, bounds, and sides of real LP SPxMainSM< BP > _boostedSimplifierMainSM Definition soplex.h:1817 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 bool getRedCost(VectorBase< R > &vector) gets the vector of reduced cost values if available; returns true on success SPxBoundFlippingRT< R > _ratiotesterBoundFlipping Definition soplex.h:1733 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 _isBoostedStartingFromSlack(bool initialSolve=true) return true if slack basis has to be loaded for boosted solver 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 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 buf... const SVectorRational & colVectorRational(int i) const returns vector of column i void _syncRationalSolution() synchronizes real solution with rational solution, i.e., copies real solution to rational solution void _storeLastStableBasis(bool vanished) void _changeLhsReal(int i, const R &lhs) changes left-hand side of row i to lhs and adjusts basis SPxSteepExPR< BP > _boostedPricerSteep Definition soplex.h:1800 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 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 _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,... void _transformEquality() introduces slack variables to transform inequality constraints into equations for both rational and r... DataArray< int > _rationalLUSolverBind Definition soplex.h:1842 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 std::string statisticString() const statistical information in form of a string void _ensureRationalLP() ensures that the rational LP is available; performs no sync DataArray< typename SPxSolverBase< R >::VarStatus > _oldBasisStatusRows Definition soplex.h:1908 void changeBoundsReal(const VectorBase< R > &lower, const VectorBase< R > &upper) changes vectors of column bounds to lower and upper @ POLISHING_FRACTIONALITY minimize number of basic slack variables, i.e. more variables between bounds Definition soplex.h:1385 @ POLISHING_INTEGRALITY maximize number of basic slack variables, i.e. more variables on bounds Definition soplex.h:1382 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 getNdualNorms(int &nnormsRow, int &nnormsCol) const gets number of available dual norms 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 getUpperReal(VectorBase< R > &upper) const gets upper bound vector 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... bool getDual(VectorBase< R > &vector) gets the dual solution vector if available; returns true on success SPxSimplifier< BP > * _boostedSimplifier Definition soplex.h:1808 void resetSettings(const bool quiet=false, const bool init=true) resets default parameter settings void changeObjReal(const VectorBase< R > &obj) changes objective function vector to obj 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 i... Rational maxAbsNonzeroRational() const returns biggest non-zero element in absolute value void _correctPrimalSolution(SolRational &sol, Rational &primalScale, int &primalSize, const int &maxDimRational, VectorBase< T > &primalReal) corrects primal solution and aligns with basis Array< UnitVectorRational * > _unitMatrixRational Definition soplex.h:1863 void _switchToStandardMode() indicate if we are testing feasibility, unboundedness or neither void _preprocessAndSolveReal(bool applyPreprocessing, volatile bool *interrupt=nullptr) solves real LP with/without preprocessing 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... bool _inStandardMode() check if we are testing feasibility, unboundedness or neither void _changeRhsReal(const VectorBase< R > &rhs) changes right-hand side vector to rhs and adjusts basis 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,... 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... 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... 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) void _storeBasisAsOldBasisBoosted(DataArray< typename SPxSolverBase< BP >::VarStatus > &rows, DataArray< typename SPxSolverBase< BP >::VarStatus > &cols) Statistics * _statistics statistics since last call to solveReal() or solveRational() Definition soplex.h:1687 bool _boostPrecision() increase the multiprecision, return false if maximum precision is reached, true otherwise bool _inFeasMode() void syncLPRational() synchronizes rational LP with real LP, i.e., copies real LP to rational LP, if sync mode is manual 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 writeFileRational(const char *filename, const NameSet *rowNames=nullptr, const NameSet *colNames=nullptr, const DIdxSet *intvars=nullptr, const bool writeZeroObjective=false) const 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 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 getRowVectorReal(int i, DSVectorBase< R > &row) const gets vector of row i void _storeBasisAsOldBasis(DataArray< typename SPxSolverBase< R >::VarStatus > &rows, DataArray< typename SPxSolverBase< R >::VarStatus > &cols) void changeLhsReal(int i, const R &lhs) changes left-hand side of row i to lhs DataArray< typename SPxSolverBase< R >::VarStatus > _oldUnbdBasisStatusCols Definition soplex.h:1917 void removeRowsRational(int perm[]) removes all rows with an index i such that perm[i] < 0; upon completion, perm[i] >= 0 indicates the n... LPRowBase< R >::Type rowTypeReal(int i) const returns inequality type of row i SPxDefaultRT< BP > _boostedRatiotesterTextbook Definition soplex.h:1802 SPxFastRT< BP > _boostedRatiotesterFast Definition soplex.h:1804 void _resetBoostedPrecision() reset the boosted precision to the default value 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 SPxSteepPR< BP > _boostedPricerQuickSteep Definition soplex.h:1799 RangeType _rangeTypeReal(const R &lower, const R &upper) const determines RangeType from real bounds bool getPrimalReal(R *p_vector, int size) 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... 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< typename SPxSolverBase< R >::VarStatus > _oldFeasBasisStatusCols Definition soplex.h:1913 Real precisionBoostTime() const time spen in higher precision since last call to solve 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 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... bool setRealParam(const RealParam param, const Real value, const bool init=true) sets real parameter value; returns true on success void _switchToUnbdMode() 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... 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; r... 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 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 int numPrecisionBoosts() const number of precision boosts since last call to solve DataArray< typename SPxSolverBase< R >::VarStatus > _oldUnbdBasisStatusRows Definition soplex.h:1916 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) bool computeBasisInverseRational() compute rational basis inverse; returns true on success 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 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 pa... 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 _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 DataArray< typename SPxSolverBase< R >::VarStatus > _oldBasisStatusCols Definition soplex.h:1909 void setIntegralityInformation(int ncols, int *intInfo) pass integrality information about the variables to the solver void _computeReducedCostViolation(SolRational &sol, Rational &redCostViolation, const bool &maximizing) computes violation of reduced costs during the refinement loop 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) bool getPrimalRational(mpq_t *vector, const int size) gets the primal solution vector if available; returns true on success (GMP only method) void _computeBoundsViolation(SolRational &sol, Rational &boundsViolation) computes violation of bounds during the refinement loop 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 SPxGeometSC< BP > _boostedScalerGeoequi Definition soplex.h:1814 bool getPrimalRay(VectorBase< R > &vector) gets the primal ray if available; returns true on success 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 mem... 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 _setupBoostedSolver() setup boosted solver before launching iteration 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 const VectorBase< R > & upperRealInternal() const returns upper bound vector bool getRedCostViolationRational(Rational &maxviol, Rational &sumviol) SPxEquiliSC< BP > _boostedScalerUniequi Definition soplex.h:1810 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 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 @ TESTDUALINF should dual infeasibility be tested in order to try to return a dual solution even if primal infeasib... Definition soplex.h:973 @ ENSURERAY re-optimize the original problem to get a proof (ray) of infeasibility/unboundedness? Definition soplex.h:1000 @ SIMPLIFIER_PARALLELCOLDETECTION Definition soplex.h:1015 @ ACCEPTCYCLING should cycling solutions be accepted during iterative refinement? Definition soplex.h:979 @ RATFAC should a rational factorization be performed after iterative refinement? Definition soplex.h:976 @ LIFTING should lifting be used to reduce range of nonzero matrix coefficients? Definition soplex.h:967 @ SIMPLIFIER_CONSTRAINTPROPAGATION Definition soplex.h:1009 @ FULLPERTURBATION perturb the entire problem or only the relevant bounds of s single pivot? Definition soplex.h:997 @ SIMPLIFIER_SINGLETONSTUFFING Definition soplex.h:1018 @ POWERSCALING round scaling factors for iterative refinement to powers of two? Definition soplex.h:985 @ SIMPLIFIER_PARALLELROWDETECTION Definition soplex.h:1012 @ RATFACJUMP continue iterative refinement with exact basic solution if not optimal? Definition soplex.h:988 void changeLowerRational(int i, const Rational &lower) changes lower bound of column i to lower @ SCALER_GEOEQUI geometric mean scaling (max 8 rounds) followed by equilibrium scaling (rows and columns) Definition soplex.h:1243 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 b... void _checkBasisScaling() check correctness of (un)scaled basis matrix operations 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 DataArray< typename SPxSolverBase< BP >::VarStatus > _tmpBasisStatusCols Definition soplex.h:1929 bool getRowViolationRational(Rational &maxviol, Rational &sumviol) Class for storing a primal-dual solution with basis information. Definition solbase.h:53 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. std::string name[SoPlexBase< R >::BOOLPARAM_COUNT] array of names for boolean parameters Definition soplex.h:1494 std::string description[SoPlexBase< R >::BOOLPARAM_COUNT] array of descriptions for boolean parameters Definition soplex.h:1496 bool defaultValue[SoPlexBase< R >::BOOLPARAM_COUNT] array of default values for boolean parameters Definition soplex.h:1498 std::string name[SoPlexBase< R >::INTPARAM_COUNT] array of names for integer parameters Definition soplex.h:1506 int lower[SoPlexBase< R >::INTPARAM_COUNT] array of lower bounds for int parameter values Definition soplex.h:1512 int upper[SoPlexBase< R >::INTPARAM_COUNT] array of upper bounds for int parameter values Definition soplex.h:1514 int defaultValue[SoPlexBase< R >::INTPARAM_COUNT] array of default values for integer parameters Definition soplex.h:1510 std::string description[SoPlexBase< R >::INTPARAM_COUNT] array of descriptions for integer parameters Definition soplex.h:1508 Real upper[SoPlexBase< R >::REALPARAM_COUNT] array of upper bounds for real parameter values Definition soplex.h:1530 Real defaultValue[SoPlexBase< R >::REALPARAM_COUNT] array of default values for real parameters Definition soplex.h:1526 Real lower[SoPlexBase< R >::REALPARAM_COUNT] array of lower bounds for real parameter values Definition soplex.h:1528 std::string description[SoPlexBase< R >::REALPARAM_COUNT] array of descriptions for real parameters Definition soplex.h:1524 std::string name[SoPlexBase< R >::REALPARAM_COUNT] array of names for real parameters Definition soplex.h:1522
|