spxlpbase.h
Go to the documentation of this file.
22 /* undefine SOPLEX_DEBUG flag from including files; if SOPLEX_DEBUG should be defined in this file, do so below */ 67 * Note, that the optimization sense is not saved directly. Instead, the objective function are multiplied by -1 to 68 * transform the LP to our standard form maximizing the objective function. However, the sense of the loaded LP can be 71 * Further, equality constraints are modelled by \f$l_r = u_r\f$. Analogously, fixed variables have \f$l_c = u_c\f$. 73 * #SPxLPBase%s are saved as an SVSet, both for columns and rows. Note that this is redundant but eases the access. 87 // ------------------------------------------------------------------------------------------------------------------ 102 // ------------------------------------------------------------------------------------------------------------------ 122 // ------------------------------------------------------------------------------------------------------------------ 380 /** Methods #maxObj() return the objective vector or its elements, after transformation to a maximization 381 * problem. Since this is how SPxLPBase internally stores any LP these methods are generally faster. The following 483 // ------------------------------------------------------------------------------------------------------------------ 501 void addRow(const S* lhsValue, const S* rowValues, const int* rowIndices, int rowSize, const S* rhsValue) 550 void addRows(const S* lhsValues, const S* rowValues, const int* rowIndices, const int* rowStarts, const int* rowLengths, const int numRows, const int numValues, const S* rhsValues) 572 LPRowSetBase<R>::add(&(lhsValues[i]), &(rowValues[rowStarts[i]]), &(rowIndices[rowStarts[i]]), rowLengths[i], &(rhsValues[i])); 603 /* preset the sizes: beware that this can irritate a consistency check call from xtend(). We need to set the 604 * sizes here, because a possible garbage collection called from xtend might destroy the sizes again. */ 656 virtual void addCol(const R& objValue, const R& lowerValue, const SVectorBase<R>& colVec, const R& upperValue) 663 void addCol(const S* objValue, const S* lowerValue, const S* colValues, const int* colIndices, int colSize, const S* upperValue) 709 void addCols(const S* objValue, const S* lowerValues, const S* colValues, const int* colIndices, const int* colStarts, const int* colLengths, const int numCols, const int numValues, const S* upperValues) 732 LPColSetBase<R>::add(&(objValue[i]), &(lowerValues[i]), &(colValues[colStarts[i]]), &(colIndices[colStarts[i]]), colLengths[i], &(upperValues[i])); 760 /* preset the sizes: beware that this can irritate a consistency check call from xtend(). We need to set the 761 * sizes here, because a possible garbage collection called from xtend might destroy the sizes again. */ 808 // ------------------------------------------------------------------------------------------------------------------ 828 /** This method removes all LPRowBase%s from the SPxLPBase with an index \p i such that \p perm[i] < 0. Upon 829 * completion, \p perm[i] >= 0 indicates the new index where the \p i'th LPRow has been moved to due to this 858 /** Removing multiple rows with one method invocation is available in two flavours. An array \p perm can be passed as 859 * third argument or not. If given, \p perm must be an array at least of size #nRows(). It is used to return the 860 * permutations resulting from this removal: \p perm[i] < 0 indicates, that the element to index \p i has been 861 * removed. Otherwise, \p perm[i] is the new index of the element with index \p i before the removal. 925 /** This method removes all LPColBase%s from the SPxLPBase with an index \p i such that \p perm[i] < 0. Upon 926 * completion, \p perm[i] >= 0 indicates the new index where the \p i 'th LPColBase has been moved to due to this 955 /** Removing multiple columns with one method invocation is available in two flavours. An array \p perm can be passed 956 * as third argument or not. If given, \p perm must be an array at least of size #nCols(). It is used to return the 957 * permutations resulting from this removal: \p perm[i] < 0 indicates, that the element to index \p i has been 958 * removed. Otherwise, \p perm[i] is the new index of the element with index \p i before the removal. 1018 // ------------------------------------------------------------------------------------------------------------------ 1023 virtual bool readLPF(std::istream& in, NameSet* rowNames = 0, NameSet* colNames = 0, DIdxSet* intVars = 0); 1026 virtual bool readMPS(std::istream& in, NameSet* rowNames = 0, NameSet* colNames = 0, DIdxSet* intVars = 0); 1030 * @param rowNames contains after the call the names of the constraints (rows) in the same order as the rows in the 1031 * LP. Constraints without a name (only possible with LPF files) are automatically assigned a name. 1033 * @param colNames contains after the call the names of the variables (columns) in the same order as the columns in 1035 * @param intVars contains after the call the indices of those variables that where marked as beeing integer in the 1039 virtual bool read(std::istream& in, NameSet* rowNames = 0, NameSet* colNames = 0, DIdxSet* intVars = 0) 1047 /* MPS starts either with a comment mark '*' or with the keyword 'NAME' at the first column. LPF starts either 1048 * with blanks, a comment mark '\' or with the keyword "MAX" or "MIN" in upper or lower case. There is no 1059 virtual bool readFile(const char* filename, NameSet* rowNames = 0, NameSet* colNames = 0, DIdxSet* intVars = 0) 1070 /** Writes a file in LP format to \p out. If \p rowNames and \p colNames are \c NULL, default names are used for the 1071 * constraints and variables. If \p intVars is not \c NULL, the variables contained in it are marked as integer in 1074 virtual void writeLPF(std::ostream& out, const NameSet* rowNames, const NameSet* colNames, const DIdxSet* p_intvars = 0) const; 1077 virtual void writeMPS(std::ostream& out, const NameSet* rowNames, const NameSet* colNames, const DIdxSet* p_intvars = 0) const; 1080 virtual void writeFile(const char* filename, const NameSet* rowNames = 0, const NameSet* colNames = 0, const DIdxSet* p_intvars = 0) const 1086 if( len_f > 4 && filename[len_f-1] == 's' && filename[len_f-2] == 'p' && filename[len_f-3] == 'm' && filename[len_f-4] == '.' ) 1177 // ------------------------------------------------------------------------------------------------------------------ 1617 /// @throw SPxInternalCodeException if the dimension of primal vector does not match number of columns or if the 1623 throw SPxInternalCodeException("XSPXLP01 Primal vector for computing row activity has wrong dimension"); 1628 throw SPxInternalCodeException("XSPXLP03 Activity vector computing row activity has wrong dimension"); 1653 /// @throw SPxInternalCodeException if the dimension of primal vector does not match number of columns or if the 1659 throw SPxInternalCodeException("XSPXLP03 Activity vector computing row activity has wrong dimension"); 1670 /// Computes "dual" activity of the columns for a given dual vector, i.e., y^T A; activity does not need to be zero 1671 /// @throw SPxInternalCodeException if dimension of dual vector does not match number of rows or if the dimension of 1677 throw SPxInternalCodeException("XSPXLP02 Dual vector for computing dual activity has wrong dimension"); 1682 throw SPxInternalCodeException("XSPXLP04 Activity vector computing dual activity has wrong dimension"); 1706 /// Updates "dual" activity of the columns for a given dual vector, i.e., y^T A; activity does not need to be zero 1707 /// @throw SPxInternalCodeException if dimension of dual vector does not match number of rows or if the dimension of 1713 throw SPxInternalCodeException("XSPXLP04 Activity vector computing dual activity has wrong dimension"); 1724 /// Updates "dual" activity of the columns for a given dual vector, i.e., y^T A; activity does not need to be zero 1725 /// @throw SPxInternalCodeException if dimension of dual vector does not match number of rows or if the dimension of 1731 throw SPxInternalCodeException("XSPXLP02 Dual vector for computing dual activity has wrong dimension"); 1736 throw SPxInternalCodeException("XSPXLP04 Activity vector computing dual activity has wrong dimension"); 1748 // ------------------------------------------------------------------------------------------------------------------ 1801 // ------------------------------------------------------------------------------------------------------------------ 1843 // ------------------------------------------------------------------------------------------------------------------ 2025 // ------------------------------------------------------------------------------------------------------------------ 2154 /* preset the sizes: beware that this can irritate a consistency check call from xtend(). We need to set the 2155 * sizes here, because a possible garbage collection called from xtend might destroy the sizes again. */ 2225 void doAddCol (const R& objValue, const R& lowerValue, const SVectorBase<R>& colVec, const R& upperValue) 2345 // ------------------------------------------------------------------------------------------------------------------ 2377 , thesense(old.thesense == SPxLPBase<S>::MINIMIZE ? SPxLPBase<R>::MINIMIZE : SPxLPBase<R>::MAXIMIZE) 2408 thesense = (old.thesense) == SPxLPBase<S>::MINIMIZE ? SPxLPBase<R>::MINIMIZE : SPxLPBase<R>::MAXIMIZE; const VectorBase< R > & obj() const Returns the vector of objective coefficients. Definition: lprowsetbase.h:165 virtual void addRows(const LPRowSetBase< R > &pset) Definition: spxlpbase.h:543 virtual void changeUpper(int i, const R &newUpper) Changes i 'th upper bound to newUpper. Definition: spxlpbase.h:1287 virtual void subDualActivity(const VectorBase< R > &dual, VectorBase< R > &activity) const Updates "dual" activity of the columns for a given dual vector, i.e., y^T A; activity does not need t... Definition: spxlpbase.h:1727 VectorBase< R > & obj_w() Returns the vector of objective coefficients (writeable). Definition: lprowsetbase.h:171 virtual void changeElement(SPxRowId rid, SPxColId cid, const R &val) Changes LP element identified by (rid, cid) to val. Definition: spxlpbase.h:1595 LPRowBase< R >::Type type(int i) const Returns the inequalitiy type of the i 'th LPRowBase. Definition: lprowsetbase.h:225 int number(const SPxColId &id) const Returns the column number of the column with identifier id. Definition: spxlpbase.h:456 Exception class for things that should NEVER happen.This class is derived from the SoPlex exception b... Definition: exceptions.h:109 void addRows(const S *lhsValues, const S *rowValues, const int *rowIndices, const int *rowStarts, const int *rowLengths, const int numRows, const int numValues, const S *rhsValues) Definition: spxlpbase.h:550 LPRowBase< R >::Type rowType(const SPxRowId &id) const Returns the inequality type of the row with identifier key. Definition: spxlpbase.h:310 void doAddCols(const LPColSetBase< R > &set) Definition: spxlpbase.h:2257 int number(const DataKey &k) const Returns number of LPColBase with DataKey k in LPColSetBase. Definition: lpcolsetbase.h:230 Set of LP columns. const VectorBase< R > & maxObj() const Returns objective vector for maximization problem. Definition: spxlpbase.h:384 const SVectorBase< R > & colVector() const Gets constraint column vector. Definition: lpcolbase.h:148 virtual void changeRange(SPxRowId id, const R &newLhs, const R &newRhs) Changes left and right hand side of row with identifier id. Definition: spxlpbase.h:1419 virtual void changeObj(SPxColId id, const R &newVal) Changes objective value of column with identifier id to newVal. Definition: spxlpbase.h:1212 virtual void changeRhs(const VectorBase< R > &newRhs) Changes right hand side vector for constraints to newRhs. Definition: spxlpbase.h:1371 Entry identifier class for items of a DataSet. Dense vector.Class VectorBase provides dense linear algebra vectors. It does not provide memory manag... Definition: dsvectorbase.h:28 const LPRowSetBase< R > * lprowset() const Returns the LP as an LPRowSetBase. Definition: spxlpbase.h:1848 Geometric mean row/column scaling.This SPxScaler implementation performs geometric mean scaling of th... Definition: spxgeometsc.h:35 void changeObj(int i, const S *newVal) changes i 'th objective vector element to newVal. Definition: spxlpbase.h:1203 virtual void changeObj(const VectorBase< R > &newObj) Changes objective vector to newObj. Definition: spxlpbase.h:1182 R & maxObj_w(int i) Returns objective value of column i for maximization problem. Definition: spxlpbase.h:1824 virtual void removeRowRange(int start, int end, int perm[]=0) Removes rows from start to end (including both). Definition: spxlpbase.h:883 int num() const Returns the number of LPColBases currently in LPColSetBase. Definition: lpcolsetbase.h:80 const SVectorBase< R > & rowVector(int i) const Returns the rowVector of the i 'th LPRowBase. Definition: lprowsetbase.h:207 Dymnamic index set. virtual void changeRhs(SPxRowId id, const R &newRhs) Changes right hand side value for row with identifier id. Definition: spxlpbase.h:1386 void changeRange(int i, const S *newLhs, const S *newRhs) Changes left and right hand side of row i. Definition: spxlpbase.h:1411 virtual bool readFile(const char *filename, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) Reads LP from a file. Definition: spxlpbase.h:1059 virtual void changeLower(SPxColId id, const R &newLower) changes lower bound of column with identifier id to newLower. Definition: spxlpbase.h:1272 int number(const SPxRowId &id) const Returns the row number of the row with identifier id. Definition: spxlpbase.h:450 Dynamic sparse vectors.Class DSVectorBase implements dynamic sparse vectors, i.e. SVectorBases with a... Definition: dsvectorbase.h:42 const R & lower(const SPxColId &id) const Returns lower bound of column with identifier id. Definition: spxlpbase.h:432 virtual void changeLhs(int i, const R &newLhs) Changes i 'th left hand side value to newLhs. Definition: spxlpbase.h:1350 virtual void changeBounds(SPxColId id, const R &newLower, const R &newUpper) Changes bounds of column with identifier id. Definition: spxlpbase.h:1336 const SVectorBase< R > & colVector(int i) const Returns column vector of column i. Definition: spxlpbase.h:341 virtual void addCols(const LPColSetBase< R > &pset) Definition: spxlpbase.h:702 virtual void changeLhs(const VectorBase< R > &newLhs) Changes left hand side vector for constraints to newLhs. Definition: spxlpbase.h:1342 void addRow(const S *lhsValue, const S *rowValues, const int *rowIndices, int rowSize, const S *rhsValue) Definition: spxlpbase.h:501 virtual void removeRows(int nums[], int n, int perm[]=0) Removes n LPRowBases. Definition: spxlpbase.h:863 virtual void changeRhs(int i, const R &newRhs) Changes i 'th right hand side value to newRhs. Definition: spxlpbase.h:1379 SPxLPBase< R > & operator=(const SPxLPBase< R > &old) Assignment operator. Definition: spxlpbase.h:2385 virtual bool read(std::istream &in, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) Reads LP in LP or MPS format from input stream in. Definition: spxlpbase.h:1039 virtual void changeRow(SPxRowId id, const LPRowBase< R > &newRow) Replaces row with identifier id with newRow. Definition: spxlpbase.h:1488 Set of strings. Definition: spxlpbase.h:95 R obj(const SPxColId &id) const Returns objective value of column with identifier id. Definition: spxlpbase.h:371 Ids for LP columns.Class SPxColId provides DataKeys for the column indices of an SPxLP. Definition: spxid.h:36 virtual bool readMPS(std::istream &in, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) Reads an LP in MPS format from input stream in. VectorBase< R > & maxObj_w() Returns vector of objective values w.r.t. maximization. Definition: lpcolsetbase.h:98 virtual void addedRows(int) Called after the last n rows have just been added. Definition: spxlpbase.h:1962 virtual void changeObjOffset(const R &o) Definition: spxlpbase.h:1611 virtual void addRow(const R &lhsValue, const SVectorBase< R > &rowVec, const R &rhsValue) Definition: spxlpbase.h:494 virtual void changeLhs(SPxRowId id, const R &newLhs) Changes left hand side value for row with identifier id. Definition: spxlpbase.h:1365 void changeLower(int i, const S *newLower) changes i 'th lower bound to newLower. Definition: spxlpbase.h:1265 virtual void changeUpper(const VectorBase< R > &newUpper) Changes vector of upper bounds to newUpper. Definition: spxlpbase.h:1278 virtual void addCol(SPxColId &id, const LPColBase< R > &col) Adds col to LPColSetVBase. Definition: spxlpbase.h:695 void memRemax(int newmax) Reallocates memory to be able to store newmax nonzeros. Definition: lprowsetbase.h:605 virtual void computeDualActivity(const VectorBase< R > &dual, VectorBase< R > &activity) const Computes "dual" activity of the columns for a given dual vector, i.e., y^T A; activity does not need ... Definition: spxlpbase.h:1673 virtual void changeRowObj(const VectorBase< R > &newRowObj) Changes row objective function vector to newRowObj. Definition: spxlpbase.h:1425 Generic Ids for LP rows or columns.Both SPxColIds and SPxRowIds may be treated uniformly as SPxIds: ... Definition: spxid.h:85 virtual void changeCol(int n, const LPColBase< R > &newCol) Replaces i 'th column of LP with newCol. Definition: spxlpbase.h:1494 virtual void changeRowObj(SPxRowId id, const R &newRowObj) Changes row objective function value for row with identifier id. Definition: spxlpbase.h:1444 virtual void changeLower(const VectorBase< R > &newLower) Changes vector of lower bounds to newLower. Definition: spxlpbase.h:1247 virtual void changeRange(const VectorBase< R > &newLhs, const VectorBase< R > &newRhs) Changes left and right hand side vectors. Definition: spxlpbase.h:1392 void getRows(int start, int end, LPRowSetBase< R > &set) const Gets rows start, ... end. Definition: spxlpbase.h:203 declaration of types for file output virtual void changeLower(int i, const R &newLower) changes i 'th lower bound to newLower. Definition: spxlpbase.h:1256 virtual void changeRange(int i, const R &newLhs, const R &newRhs) Changes left and right hand side of row i. Definition: spxlpbase.h:1401 const R & lhs(const SPxRowId &id) const Returns left hand side of row with identifier id. Definition: spxlpbase.h:254 Row and columns Id's SPxLP. SVectorBase< R > & colVector_w(int i) Definition: lpcolsetbase.h:200 LPRowSetBase< R > & operator=(const LPRowSetBase< R > &rs) Assignment operator. Definition: lprowsetbase.h:659 SVectorBase< R > & rowVector_w(int i) Returns a writable rowVector of the i 'th LPRowBase. Definition: lprowsetbase.h:201 Wrapper for several output streams. A verbosity level is used to decide which stream to use and wheth... Definition: spxout.h:63 void changeBounds(int i, const S *newLower, const S *newUpper) Changes bounds of column i to newLower and newUpper. Definition: spxlpbase.h:1328 virtual bool readLPF(std::istream &in, NameSet *rowNames=0, NameSet *colNames=0, DIdxSet *intVars=0) Reads LP in LP format from input stream in. virtual void removeCols(int nums[], int n, int perm[]=0) Removes n LPCols. Definition: spxlpbase.h:960 void add2(const DataKey &k, int n, const int idx[], const R val[]) Adds n nonzero (idx, val)-pairs to rowVector with DataKey k. Definition: lprowsetbase.h:442 void addCols(const S *objValue, const S *lowerValues, const S *colValues, const int *colIndices, const int *colStarts, const int *colLengths, const int numCols, const int numValues, const S *upperValues) Definition: spxlpbase.h:709 virtual void writeMPS(std::ostream &out, const NameSet *rowNames, const NameSet *colNames, const DIdxSet *p_intvars=0) const Writes a file in MPS format to out. Dynamic index set.Class DIdxSet provides dynamic IdxSet in the sense, that no restrictions are posed ... Definition: didxset.h:42 void doAddRows(const LPRowSetBase< R > &set) Definition: spxlpbase.h:2104 LPColSetBase< R > & operator=(const LPColSetBase< R > &rs) Assignment operator. Definition: lpcolsetbase.h:576 const SVectorBase< R > & colVector(const SPxColId &id) const Returns column vector of column with identifier id. Definition: spxlpbase.h:347 virtual void addRows(SPxRowId id[], const LPRowSetBase< R > &set) adds all LPRowBases of pset to LPRowSetBase. Definition: spxlpbase.h:640 const R & upper(const SPxColId &id) const Returns upper bound of column with identifier id. Definition: spxlpbase.h:414 virtual void changeBounds(const VectorBase< R > &newLower, const VectorBase< R > &newUpper) Changes variable bounds to newLower and newUpper. Definition: spxlpbase.h:1309 (In)equality for LPs.Class LPRowBase provides constraints for linear programs in the form where a is... Definition: lprowbase.h:45 const R & rhs(const SPxRowId &id) const Returns right hand side of row with identifier id. Definition: spxlpbase.h:236 void getCols(int start, int end, LPColSetBase< R > &set) const Gets columns start, ..., end. Definition: spxlpbase.h:332 void added2Set(SVSetBase< R > &set, const SVSetBase< R > &addset, int n) Definition: spxlpbase.h:1970 Debugging, floating point type and parameter definitions. Simplex basis.Consider the linear program as provided from class SPxLP: where , and ... Definition: spxbasis.h:82 virtual void removeRows(SPxRowId id[], int n, int perm[]=0) Definition: spxlpbase.h:838 Set of strings.Class NameSet implements a symbol or name table. It allows to store or remove names (i... Definition: nameset.h:61 virtual void addCol(const R &objValue, const R &lowerValue, const SVectorBase< R > &colVec, const R &upperValue) Definition: spxlpbase.h:656 void changeLhs(int i, const S *newLhs) Changes i 'th left hand side value to newLhs. Definition: spxlpbase.h:1358 VectorBase< R > & multAdd(const S &x, const VectorBase< T > &vec) Addition of scaled vector. Definition: vectorbase.h:369 Collection of dense, sparse, and semi-sparse vectors. SPxLPBase< R > & operator=(const SPxLPBase< S > &old) Assignment operator. Definition: spxlpbase.h:2402 virtual void changeUpper(SPxColId id, const R &newUpper) Changes upper bound of column with identifier id to newLower. Definition: spxlpbase.h:1303 void getRow(const SPxRowId &id, LPRowBase< R > &row) const Gets row with identifier id. Definition: spxlpbase.h:197 Everything should be within this namespace. virtual void changeMaxObj(int i, const R &newVal) changes i 'th objective vector element to newVal. Definition: spxlpbase.h:1226 void changeElement(int i, int j, const S *val) Changes LP element (i, j) to val. Definition: spxlpbase.h:1564 virtual void changeBounds(int i, const R &newLower, const R &newUpper) Changes bounds of column i to newLower and newUpper. Definition: spxlpbase.h:1318 Saving LPs in a form suitable for SoPlex.Class SPxLPBase provides the data structures required for sa... Definition: spxlpbase.h:76 Definition: spxlpbase.h:94 Set of LP columns.Class LPColSetBase implements a set of LPColBase%s. Unless for memory limitations... Definition: lpcolsetbase.h:43 R rowObj(const SPxRowId &id) const Returns row objective function value of row with identifier id. Definition: spxlpbase.h:277 virtual void writeLPF(std::ostream &out, const NameSet *rowNames, const NameSet *colNames, const DIdxSet *p_intvars=0) const virtual void clearRowObjs() Clears row objective function values for all rows. Definition: spxlpbase.h:1450 virtual void changeRow(int n, const LPRowBase< R > &newRow) Replaces i 'th row of LP with newRow. Definition: spxlpbase.h:1456 virtual void changeMaxObj(SPxColId id, const R &newVal) Changes objective value of column with identifier id to newVal. Definition: spxlpbase.h:1241 void setRowVector(const DSVectorBase< R > &p_vec) access constraint row vector. Definition: lprowbase.h:245 (In)equality for LPs. const R & maxObj(int i) const Returns objective value of column i for maximization problem. Definition: spxlpbase.h:390 int number(const DataKey &k) const Returns the number of the LPRowBase with DataKey k in LPRowSetBase. Definition: lprowsetbase.h:296 virtual void changeRowObj(int i, const R &newRowObj) Changes i 'th row objective function value to newRowObj. Definition: spxlpbase.h:1435 LP scaler abstract base class.Instances of classes derived from SPxScaler may be loaded to SoPlex in ... Definition: spxscaler.h:39 virtual void addRow(SPxRowId &id, const LPRowBase< R > &row) Adds row to LPRowSetBase. Definition: spxlpbase.h:536 Set of LP rows.Class LPRowSetBase implements a set of LPRowBase%s. Unless for memory limitations... Definition: lprowsetbase.h:44 int number(const SPxId &id) const Returns the row or column number for identifier id. Definition: spxlpbase.h:462 virtual void changeElement(int i, int j, const R &val) Changes LP element (i, j) to val. Definition: spxlpbase.h:1532 virtual void changeMaxObj(const VectorBase< R > &newObj) Changes objective vector to newObj. Definition: spxlpbase.h:1218 LPRowBase< R >::Type rowType(int i) const Returns the inequality type of the i'th LPRow. Definition: spxlpbase.h:304 virtual void changeSense(SPxSense sns) Changes optimization sense to sns. Definition: spxlpbase.h:1601 void xtend(int n, int newmax) Extends column n to fit newmax nonzeros. Definition: lpcolsetbase.h:350 void printProblemStatistics(std::ostream &os) Definition: spxlpbase.h:1097 const VectorBase< R > & rhs() const Returns the vector of rhs values. Definition: lprowsetbase.h:129 const LPColSetBase< R > * lpcolset() const Returns the LP as an LPColSetBase. Definition: spxlpbase.h:1854 LP column. virtual void removeColRange(int start, int end, int perm[]=0) Removes columns from start to end (including both). Definition: spxlpbase.h:980 virtual void removeCols(SPxColId id[], int n, int perm[]=0) Definition: spxlpbase.h:935 void changeUpper(int i, const S *newUpper) Changes i 'th upper bound to newUpper. Definition: spxlpbase.h:1296 void getCol(const SPxColId &id, LPColBase< R > &col) const Gets column with identifier id. Definition: spxlpbase.h:326 virtual void changeObj(int i, const R &newVal) changes i 'th objective vector element to newVal. Definition: spxlpbase.h:1193 const R & maxRowObj(const SPxRowId &id) const Returns row objective function value of row with identifier id. Definition: spxlpbase.h:298 Sparse vectors.Class SVectorBase provides packed sparse vectors. Such are a sparse vectors... Definition: dvectorbase.h:31 const SVectorBase< R > & rowVector(int i) const Gets row vector of row i. Definition: spxlpbase.h:212 virtual void addPrimalActivity(const SVectorBase< R > &primal, VectorBase< R > &activity) const Updates activity of the rows for a given primal vector; activity does not need to be zero... Definition: spxlpbase.h:1655 void add2(const DataKey &k, int n, const int idx[], const R val[]) Definition: lpcolsetbase.h:362 const R & objOffset() const Returns the objective function value offset. Definition: spxlpbase.h:444 Ids for LP rows.Class SPxRowId provides DataKeys for the row indices of an SPxLP. ... Definition: spxid.h:55 void addCol(const S *objValue, const S *lowerValue, const S *colValues, const int *colIndices, int colSize, const S *upperValue) Definition: spxlpbase.h:663 const R & maxObj(const SPxColId &id) const Returns objective value of column with identifier id for maximization problem. Definition: spxlpbase.h:396 void setColVector(const SVectorBase< R > &p_vec) Sets constraint column vector. Definition: lpcolbase.h:154 void getRowObj(VectorBase< R > &prowobj) const Gets row objective function vector. Definition: spxlpbase.h:260 virtual void addDualActivity(const SVectorBase< R > &dual, VectorBase< R > &activity) const Updates "dual" activity of the columns for a given dual vector, i.e., y^T A; activity does not need t... Definition: spxlpbase.h:1709 VectorBase< R > & rhs_w() Returns the vector of rhs values (writeable). Definition: lprowsetbase.h:135 Save arrays of data objects. virtual void changeCol(SPxColId id, const LPColBase< R > &newCol) Replaces column with identifier id with newCol. Definition: spxlpbase.h:1526 const SVectorBase< R > & rowVector(const SPxRowId &id) const Gets row vector of row with identifier id. Definition: spxlpbase.h:218 Equilibrium row/column scaling.This SPxScaler implementation performs equilibrium scaling of the LPs ... Definition: spxequilisc.h:35 Set of LP columns. virtual void writeFile(const char *filename, const NameSet *rowNames=0, const NameSet *colNames=0, const DIdxSet *p_intvars=0) const Write loaded LP to filename. Definition: spxlpbase.h:1080 void changeMaxObj(int i, const S *newVal) changes i 'th objective vector element to newVal. Definition: spxlpbase.h:1234 void doAddCol(const R &objValue, const R &lowerValue, const SVectorBase< R > &colVec, const R &upperValue) Definition: spxlpbase.h:2225 virtual void computePrimalActivity(const VectorBase< R > &primal, VectorBase< R > &activity) const Computes activity of the rows for a given primal vector; activity does not need to be zero... Definition: spxlpbase.h:1619 LP column.Class LPColBase provides a datatype for storing the column of an LP a the form similar to ... Definition: lpcolbase.h:45 Sparse vector set.Class SVSetBase provides a set of sparse vectors SVectorBase. All SVectorBases in a... Definition: ssvectorbase.h:33 VectorBase< R > & multSub(const S &x, const SVectorBase< T > &vec) Subtraction of scaled vector. Definition: basevectors.h:290 void doAddRow(const R &lhsValue, const SVectorBase< R > &rowVec, const R &rhsValue) Definition: spxlpbase.h:2074 virtual void addedCols(int) Called after the last n columns have just been added. Definition: spxlpbase.h:1966 const SVectorBase< R > & colVector(int i) const Returns colVector of i 'th LPColBase in LPColSetBase. Definition: lpcolsetbase.h:206 LP simplifier for removing uneccessary row/columns.This SPxSimplifier is mainly based on the paper "P... Definition: spxmainsm.h:60 virtual void addCols(SPxColId id[], const LPColSetBase< R > &set) Adds all LPColBases of set to LPColSetBase. Definition: spxlpbase.h:797 |