diff options
Diffstat (limited to 'thirdparty/linux/include/coin/ClpGubMatrix.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/ClpGubMatrix.hpp | 358 |
1 files changed, 358 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/ClpGubMatrix.hpp b/thirdparty/linux/include/coin/ClpGubMatrix.hpp new file mode 100644 index 0000000..26c3f62 --- /dev/null +++ b/thirdparty/linux/include/coin/ClpGubMatrix.hpp @@ -0,0 +1,358 @@ +/* $Id: ClpGubMatrix.hpp 1665 2011-01-04 17:55:54Z lou $ */ +// Copyright (C) 2003, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef ClpGubMatrix_H +#define ClpGubMatrix_H + + +#include "CoinPragma.hpp" + +#include "ClpPackedMatrix.hpp" +class ClpSimplex; +/** This implements Gub rows plus a ClpPackedMatrix. + + There will be a version using ClpPlusMinusOne matrix but + there is no point doing one with ClpNetworkMatrix (although + an embedded network is attractive). + +*/ + +class ClpGubMatrix : public ClpPackedMatrix { + +public: + /**@name Main functions provided */ + //@{ + /** Returns a new matrix in reverse order without gaps (GUB wants NULL) */ + virtual ClpMatrixBase * reverseOrderedCopy() const; + /// Returns number of elements in column part of basis + virtual CoinBigIndex countBasis(const int * whichColumn, + int & numberColumnBasic); + /// Fills in column part of basis + virtual void fillBasis(ClpSimplex * model, + const int * whichColumn, + int & numberColumnBasic, + int * row, int * start, + int * rowCount, int * columnCount, + CoinFactorizationDouble * element); + /** Unpacks a column into an CoinIndexedvector + */ + virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray, + int column) const ; + /** Unpacks a column into an CoinIndexedvector + ** in packed foramt + Note that model is NOT const. Bounds and objective could + be modified if doing column generation (just for this variable) */ + virtual void unpackPacked(ClpSimplex * model, + CoinIndexedVector * rowArray, + int column) const; + /** Adds multiple of a column into an CoinIndexedvector + You can use quickAdd to add to vector */ + virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray, + int column, double multiplier) const ; + /** Adds multiple of a column into an array */ + virtual void add(const ClpSimplex * model, double * array, + int column, double multiplier) const; + /// Partial pricing + virtual void partialPricing(ClpSimplex * model, double start, double end, + int & bestSequence, int & numberWanted); + /// Returns number of hidden rows e.g. gub + virtual int hiddenRows() const; + //@} + + /**@name Matrix times vector methods */ + //@{ + + using ClpPackedMatrix::transposeTimes ; + /** Return <code>x * scalar * A + y</code> in <code>z</code>. + Can use y as temporary array (will be empty at end) + Note - If x packed mode - then z packed mode + Squashes small elements and knows about ClpSimplex */ + virtual void transposeTimes(const ClpSimplex * model, double scalar, + const CoinIndexedVector * x, + CoinIndexedVector * y, + CoinIndexedVector * z) const; + /** Return <code>x * scalar * A + y</code> in <code>z</code>. + Can use y as temporary array (will be empty at end) + Note - If x packed mode - then z packed mode + Squashes small elements and knows about ClpSimplex. + This version uses row copy*/ + virtual void transposeTimesByRow(const ClpSimplex * model, double scalar, + const CoinIndexedVector * x, + CoinIndexedVector * y, + CoinIndexedVector * z) const; + /** Return <code>x *A</code> in <code>z</code> but + just for indices in y. + Note - z always packed mode */ + virtual void subsetTransposeTimes(const ClpSimplex * model, + const CoinIndexedVector * x, + const CoinIndexedVector * y, + CoinIndexedVector * z) const; + /** expands an updated column to allow for extra rows which the main + solver does not know about and returns number added if mode 0. + If mode 1 deletes extra entries + + This active in Gub + */ + virtual int extendUpdated(ClpSimplex * model, CoinIndexedVector * update, int mode); + /** + mode=0 - Set up before "update" and "times" for primal solution using extended rows + mode=1 - Cleanup primal solution after "times" using extended rows. + mode=2 - Check (or report on) primal infeasibilities + */ + virtual void primalExpanded(ClpSimplex * model, int mode); + /** + mode=0 - Set up before "updateTranspose" and "transposeTimes" for duals using extended + updates array (and may use other if dual values pass) + mode=1 - Update dual solution after "transposeTimes" using extended rows. + mode=2 - Compute all djs and compute key dual infeasibilities + mode=3 - Report on key dual infeasibilities + mode=4 - Modify before updateTranspose in partial pricing + */ + virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array, + double * other, int mode); + /** + mode=0 - Create list of non-key basics in pivotVariable_ using + number as numberBasic in and out + mode=1 - Set all key variables as basic + mode=2 - return number extra rows needed, number gives maximum number basic + mode=3 - before replaceColumn + mode=4 - return 1 if can do primal, 2 if dual, 3 if both + mode=5 - save any status stuff (when in good state) + mode=6 - restore status stuff + mode=7 - flag given variable (normally sequenceIn) + mode=8 - unflag all variables + mode=9 - synchronize costs + mode=10 - return 1 if there may be changing bounds on variable (column generation) + mode=11 - make sure set is clean (used when a variable rejected - but not flagged) + mode=12 - after factorize but before permute stuff + mode=13 - at end of simplex to delete stuff + */ + virtual int generalExpanded(ClpSimplex * model, int mode, int & number); + /** + update information for a pivot (and effective rhs) + */ + virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue); + /// Sets up an effective RHS and does gub crash if needed + virtual void useEffectiveRhs(ClpSimplex * model, bool cheapest = true); + /** Returns effective RHS offset if it is being used. This is used for long problems + or big gub or anywhere where going through full columns is + expensive. This may re-compute */ + virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false, + bool check = false); + /** This is local to Gub to allow synchronization: + mode=0 when status of basis is good + mode=1 when variable is flagged + mode=2 when all variables unflagged (returns number flagged) + mode=3 just reset costs (primal) + mode=4 correct number of dual infeasibilities + mode=5 return 4 if time to re-factorize + mode=6 - return 1 if there may be changing bounds on variable (column generation) + mode=7 - do extra restores for column generation + mode=8 - make sure set is clean + mode=9 - adjust lower, upper on set by incoming + */ + virtual int synchronize(ClpSimplex * model, int mode); + /// Correct sequence in and out to give true value + virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ; + //@} + + + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + ClpGubMatrix(); + /** Destructor */ + virtual ~ClpGubMatrix(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + ClpGubMatrix(const ClpGubMatrix&); + /** The copy constructor from an CoinPackedMatrix. */ + ClpGubMatrix(const CoinPackedMatrix&); + /** Subset constructor (without gaps). Duplicates are allowed + and order is as given */ + ClpGubMatrix (const ClpGubMatrix & wholeModel, + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns); + ClpGubMatrix (const CoinPackedMatrix & wholeModel, + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns); + + /** This takes over ownership (for space reasons) */ + ClpGubMatrix(CoinPackedMatrix * matrix); + + /** This takes over ownership (for space reasons) and is the + real constructor*/ + ClpGubMatrix(ClpPackedMatrix * matrix, int numberSets, + const int * start, const int * end, + const double * lower, const double * upper, + const unsigned char * status = NULL); + + ClpGubMatrix& operator=(const ClpGubMatrix&); + /// Clone + virtual ClpMatrixBase * clone() const ; + /** Subset clone (without gaps). Duplicates are allowed + and order is as given */ + virtual ClpMatrixBase * subsetClone ( + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns) const ; + /** redoes next_ for a set. */ + void redoSet(ClpSimplex * model, int newKey, int oldKey, int iSet); + //@} + /**@name gets and sets */ + //@{ + /// Status + inline ClpSimplex::Status getStatus(int sequence) const { + return static_cast<ClpSimplex::Status> (status_[sequence] & 7); + } + inline void setStatus(int sequence, ClpSimplex::Status status) { + unsigned char & st_byte = status_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(st_byte | status); + } + /// To flag a variable + inline void setFlagged( int sequence) { + status_[sequence] = static_cast<unsigned char>(status_[sequence] | 64); + } + inline void clearFlagged( int sequence) { + status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64); + } + inline bool flagged(int sequence) const { + return ((status_[sequence] & 64) != 0); + } + /// To say key is above ub + inline void setAbove( int sequence) { + unsigned char iStat = status_[sequence]; + iStat = static_cast<unsigned char>(iStat & ~24); + status_[sequence] = static_cast<unsigned char>(iStat | 16); + } + /// To say key is feasible + inline void setFeasible( int sequence) { + unsigned char iStat = status_[sequence]; + iStat = static_cast<unsigned char>(iStat & ~24); + status_[sequence] = static_cast<unsigned char>(iStat | 8); + } + /// To say key is below lb + inline void setBelow( int sequence) { + unsigned char iStat = status_[sequence]; + iStat = static_cast<unsigned char>(iStat & ~24); + status_[sequence] = iStat; + } + inline double weight( int sequence) const { + int iStat = status_[sequence] & 31; + iStat = iStat >> 3; + return static_cast<double> (iStat - 1); + } + /// Starts + inline int * start() const { + return start_; + } + /// End + inline int * end() const { + return end_; + } + /// Lower bounds on sets + inline double * lower() const { + return lower_; + } + /// Upper bounds on sets + inline double * upper() const { + return upper_; + } + /// Key variable of set + inline int * keyVariable() const { + return keyVariable_; + } + /// Backward pointer to set number + inline int * backward() const { + return backward_; + } + /// Number of sets (gub rows) + inline int numberSets() const { + return numberSets_; + } + /// Switches off dj checking each factorization (for BIG models) + void switchOffCheck(); + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Sum of dual infeasibilities + double sumDualInfeasibilities_; + /// Sum of primal infeasibilities + double sumPrimalInfeasibilities_; + /// Sum of Dual infeasibilities using tolerance based on error in duals + double sumOfRelaxedDualInfeasibilities_; + /// Sum of Primal infeasibilities using tolerance based on error in primals + double sumOfRelaxedPrimalInfeasibilities_; + /// Infeasibility weight when last full pass done + double infeasibilityWeight_; + /// Starts + int * start_; + /// End + int * end_; + /// Lower bounds on sets + double * lower_; + /// Upper bounds on sets + double * upper_; + /// Status of slacks + mutable unsigned char * status_; + /// Saved status of slacks + unsigned char * saveStatus_; + /// Saved key variables + int * savedKeyVariable_; + /// Backward pointer to set number + int * backward_; + /// Backward pointer to pivot row !!! + int * backToPivotRow_; + /// Change in costs for keys + double * changeCost_; + /// Key variable of set + mutable int * keyVariable_; + /** Next basic variable in set - starts at key and end with -(set+1). + Now changes to -(nonbasic+1). + next_ has extra space for 2* longest set */ + mutable int * next_; + /// Backward pointer to index in CoinIndexedVector + int * toIndex_; + // Reverse pointer from index to set + int * fromIndex_; + /// Pointer back to model + ClpSimplex * model_; + /// Number of dual infeasibilities + int numberDualInfeasibilities_; + /// Number of primal infeasibilities + int numberPrimalInfeasibilities_; + /** If pricing will declare victory (i.e. no check every factorization). + -1 - always check + 0 - don't check + 1 - in don't check mode but looks optimal + */ + int noCheck_; + /// Number of sets (gub rows) + int numberSets_; + /// Number in vector without gub extension + int saveNumber_; + /// Pivot row of possible next key + int possiblePivotKey_; + /// Gub slack in (set number or -1) + int gubSlackIn_; + /// First gub variables (same as start_[0] at present) + int firstGub_; + /// last gub variable (same as end_[numberSets_-1] at present) + int lastGub_; + /** type of gub - 0 not contiguous, 1 contiguous + add 8 bit to say no ubs on individual variables */ + int gubType_; + //@} +}; + +#endif |