Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ClpMatrixBase.hpp
Go to the documentation of this file.
1 /* $Id: ClpMatrixBase.hpp 2078 2015-01-05 12:39:49Z forrest $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 #ifndef ClpMatrixBase_H
7 #define ClpMatrixBase_H
8 
9 #include "CoinPragma.hpp"
10 #include "CoinTypes.hpp"
11 
12 #include "CoinPackedMatrix.hpp"
13 class CoinIndexedVector;
14 class ClpSimplex;
15 class ClpModel;
16 // Compilers can produce better code if they know about __restrict
17 #ifndef COIN_RESTRICT
18 #ifdef COIN_USE_RESTRICT
19 #define COIN_RESTRICT __restrict
20 #else
21 #define COIN_RESTRICT
22 #endif
23 #endif
24 
39 
40 public:
43  virtual CoinPackedMatrix * getPackedMatrix() const = 0;
46  virtual bool isColOrdered() const = 0;
48  virtual CoinBigIndex getNumElements() const = 0;
50  virtual int getNumCols() const = 0;
52  virtual int getNumRows() const = 0;
53 
58  virtual const double * getElements() const = 0;
64  virtual const int * getIndices() const = 0;
65 
66  virtual const CoinBigIndex * getVectorStarts() const = 0;
68  virtual const int * getVectorLengths() const = 0 ;
70  virtual int getVectorLength(int index) const ;
72  virtual void deleteCols(const int numDel, const int * indDel) = 0;
74  virtual void deleteRows(const int numDel, const int * indDel) = 0;
75 #ifndef CLP_NO_VECTOR
76  virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
79  virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
80 #endif
81 
84  virtual void modifyCoefficient(int row, int column, double newElement,
85  bool keepZero = false);
90  virtual int appendMatrix(int number, int type,
91  const CoinBigIndex * starts, const int * index,
92  const double * element, int numberOther = -1);
93 
96  virtual ClpMatrixBase * reverseOrderedCopy() const {
97  return NULL;
98  }
99 
101  virtual CoinBigIndex countBasis(const int * whichColumn,
102  int & numberColumnBasic) = 0;
104  virtual void fillBasis(ClpSimplex * model,
105  const int * whichColumn,
106  int & numberColumnBasic,
107  int * row, int * start,
108  int * rowCount, int * columnCount,
109  CoinFactorizationDouble * element) = 0;
113  virtual int scale(ClpModel * , const ClpSimplex * = NULL) const {
114  return 1;
115  }
118  virtual void scaleRowCopy(ClpModel * ) const { }
120  virtual bool canGetRowCopy() const {
121  return true;
122  }
126  inline virtual ClpMatrixBase * scaledColumnCopy(ClpModel * ) const {
127  return this->clone();
128  }
129 
140  virtual bool allElementsInRange(ClpModel * ,
141  double , double ,
142  int = 15) {
143  return true;
144  }
150  virtual void setDimensions(int numrows, int numcols);
154  virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
155  double & smallestPositive, double & largestPositive);
156 
159  virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
160  int column) const = 0;
165  virtual void unpackPacked(ClpSimplex * model,
166  CoinIndexedVector * rowArray,
167  int column) const = 0;
172  virtual int refresh(ClpSimplex * ) {
173  return 0;
174  }
175 
176  // Really scale matrix
177  virtual void reallyScale(const double * rowScale, const double * columnScale);
183  virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
186  virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
187  int column, double multiplier) const = 0;
189  virtual void add(const ClpSimplex * model, double * array,
190  int column, double multiplier) const = 0;
192  virtual void releasePackedMatrix() const = 0;
194  virtual bool canDoPartialPricing() const;
196  virtual int hiddenRows() const;
198  virtual void partialPricing(ClpSimplex * model, double start, double end,
199  int & bestSequence, int & numberWanted);
209  virtual int extendUpdated(ClpSimplex * model, CoinIndexedVector * update, int mode);
216  virtual void primalExpanded(ClpSimplex * model, int mode);
226  virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
227  double * other, int mode);
247  virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
251  virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
255  virtual void createVariable(ClpSimplex * model, int & bestSequence);
258  virtual int checkFeasible(ClpSimplex * model, double & sum) const ;
260  double reducedCost(ClpSimplex * model, int sequence) const;
262  virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
264 
265  //---------------------------------------------------------------------------
273  virtual void times(double scalar,
274  const double * COIN_RESTRICT x, double * COIN_RESTRICT y) const = 0;
278  virtual void times(double scalar,
279  const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
280  const double * COIN_RESTRICT rowScale,
281  const double * COIN_RESTRICT columnScale) const;
285  virtual void transposeTimes(double scalar,
286  const double * COIN_RESTRICT x, double * COIN_RESTRICT y) const = 0;
290  virtual void transposeTimes(double scalar,
291  const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
292  const double * COIN_RESTRICT rowScale,
293  const double * COIN_RESTRICT columnScale,
294  double * COIN_RESTRICT spare = NULL) const;
295 #if COIN_LONG_WORK
296  // For long double versions (aborts if not supported)
297  virtual void times(CoinWorkDouble scalar,
299  virtual void transposeTimes(CoinWorkDouble scalar,
301 #endif
302 
306  virtual void transposeTimes(const ClpSimplex * model, double scalar,
307  const CoinIndexedVector * x,
308  CoinIndexedVector * y,
309  CoinIndexedVector * z) const = 0;
314  virtual void subsetTransposeTimes(const ClpSimplex * model,
315  const CoinIndexedVector * x,
316  const CoinIndexedVector * y,
317  CoinIndexedVector * z) const = 0;
320  virtual bool canCombine(const ClpSimplex * ,
321  const CoinIndexedVector * ) const {
322  return false;
323  }
325  virtual void transposeTimes2(const ClpSimplex * model,
326  const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
327  const CoinIndexedVector * pi2,
328  CoinIndexedVector * spare,
329  double referenceIn, double devex,
330  // Array for exact devex to say what is in reference framework
331  unsigned int * reference,
332  double * weights, double scaleFactor);
334  virtual void subsetTimes2(const ClpSimplex * model,
335  CoinIndexedVector * dj1,
336  const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
337  double referenceIn, double devex,
338  // Array for exact devex to say what is in reference framework
339  unsigned int * reference,
340  double * weights, double scaleFactor);
345  virtual void listTransposeTimes(const ClpSimplex * model,
346  double * x,
347  int * y,
348  int number,
349  double * z) const;
351 
352  virtual ClpMatrixBase * clone() const = 0;
359  virtual ClpMatrixBase * subsetClone (
360  int numberRows, const int * whichRows,
361  int numberColumns, const int * whichColumns) const;
363  virtual void backToBasics() {}
370  inline int type() const {
371  return type_;
372  }
374  void setType(int newtype) {
375  type_ = newtype;
376  }
378  void useEffectiveRhs(ClpSimplex * model);
382  virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
383  bool check = false);
385  inline int lastRefresh() const {
386  return lastRefresh_;
387  }
389  inline int refreshFrequency() const {
390  return refreshFrequency_;
391  }
392  inline void setRefreshFrequency(int value) {
393  refreshFrequency_ = value;
394  }
396  inline bool skipDualCheck() const {
397  return skipDualCheck_;
398  }
399  inline void setSkipDualCheck(bool yes) {
400  skipDualCheck_ = yes;
401  }
404  inline int minimumObjectsScan() const {
405  return minimumObjectsScan_;
406  }
407  inline void setMinimumObjectsScan(int value) {
408  minimumObjectsScan_ = value;
409  }
411  inline int minimumGoodReducedCosts() const {
413  }
414  inline void setMinimumGoodReducedCosts(int value) {
415  minimumGoodReducedCosts_ = value;
416  }
418  inline double startFraction() const {
419  return startFraction_;
420  }
421  inline void setStartFraction(double value) {
422  startFraction_ = value;
423  }
425  inline double endFraction() const {
426  return endFraction_;
427  }
428  inline void setEndFraction(double value) {
429  endFraction_ = value;
430  }
432  inline double savedBestDj() const {
433  return savedBestDj_;
434  }
435  inline void setSavedBestDj(double value) {
436  savedBestDj_ = value;
437  }
439  inline int originalWanted() const {
440  return originalWanted_;
441  }
442  inline void setOriginalWanted(int value) {
443  originalWanted_ = value;
444  }
446  inline int currentWanted() const {
447  return currentWanted_;
448  }
449  inline void setCurrentWanted(int value) {
450  currentWanted_ = value;
451  }
453  inline int savedBestSequence() const {
454  return savedBestSequence_;
455  }
456  inline void setSavedBestSequence(int value) {
457  savedBestSequence_ = value;
458  }
460 
461 
462 protected:
463 
469  ClpMatrixBase();
471 public:
472  virtual ~ClpMatrixBase();
473 protected:
474  // Copy
476  // Assignment
479 
480 
481 protected:
488  double * rhsOffset_;
492  double endFraction_;
494  double savedBestDj_;
502  int type_;
518 };
519 // bias for free variables
520 #define FREE_BIAS 1.0e1
521 // Acceptance criteria for free variables
522 #define FREE_ACCEPT 1.0e2
523 
524 #endif
virtual const double * getElements() const =0
A vector containing the elements in the packed matrix.
virtual void appendRows(int number, const CoinPackedVectorBase *const *rows)
Append Rows.
void setCurrentWanted(int value)
virtual bool canCombine(const ClpSimplex *, const CoinIndexedVector *) const
Returns true if can combine transposeTimes and subsetTransposeTimes and if it would be faster...
int type() const
Returns type.
virtual const CoinBigIndex * getVectorStarts() const =0
int refreshFrequency() const
If rhsOffset used this is refresh frequency (0==off)
virtual void rangeOfElements(double &smallestNegative, double &largestNegative, double &smallestPositive, double &largestPositive)
Returns largest and smallest elements of both signs.
double startFraction() const
Current start of search space in matrix (as fraction)
virtual int getNumRows() const =0
Number of rows.
virtual bool isColOrdered() const =0
Whether the packed matrix is column major ordered or not.
Abstract base class for Clp Matrices.
virtual bool canDoPartialPricing() const
Says whether it can do partial pricing.
virtual void deleteRows(const int numDel, const int *indDel)=0
Delete the rows whose indices are listed in indDel.
virtual void dualExpanded(ClpSimplex *model, CoinIndexedVector *array, double *other, int mode)
utility dual function for dealing with dynamic constraints mode=0 - Set up before "updateTranspose" a...
virtual void appendCols(int number, const CoinPackedVectorBase *const *columns)
Append Columns.
virtual int getNumCols() const =0
Number of columns.
virtual CoinBigIndex countBasis(const int *whichColumn, int &numberColumnBasic)=0
Returns number of elements in column part of basis.
void setRefreshFrequency(int value)
double savedBestDj() const
Current best reduced cost.
double * rhsOffset_
Effective RHS offset if it is being used.
int lastRefresh() const
If rhsOffset used this is iteration last refreshed.
virtual int generalExpanded(ClpSimplex *model, int mode, int &number)
general utility function for dealing with dynamic constraints mode=0 - Create list of non-key basics ...
double reducedCost(ClpSimplex *model, int sequence) const
Returns reduced cost of a variable.
void setSavedBestSequence(int value)
virtual bool canGetRowCopy() const
Returns true if can create row copy.
int savedBestSequence_
Saved best sequence in pricing.
virtual void fillBasis(ClpSimplex *model, const int *whichColumn, int &numberColumnBasic, int *row, int *start, int *rowCount, int *columnCount, CoinFactorizationDouble *element)=0
Fills in column part of basis.
int minimumGoodReducedCosts() const
Partial pricing tuning parameter - minimum number of negative reduced costs to get.
virtual void transposeTimes2(const ClpSimplex *model, const CoinIndexedVector *pi1, CoinIndexedVector *dj1, const CoinIndexedVector *pi2, CoinIndexedVector *spare, double referenceIn, double devex, unsigned int *reference, double *weights, double scaleFactor)
Updates two arrays for steepest and does devex weights (need not be coded)
int currentWanted_
Current number of negative reduced costs which we still need.
int savedBestSequence() const
Current best sequence.
virtual ~ClpMatrixBase()
Destructor (has to be public)
virtual void add(const ClpSimplex *model, CoinIndexedVector *rowArray, int column, double multiplier) const =0
Adds multiple of a column into an CoinIndexedvector You can use quickAdd to add to vector...
virtual CoinPackedMatrix * getPackedMatrix() const =0
Return a complete CoinPackedMatrix.
virtual void unpack(const ClpSimplex *model, CoinIndexedVector *rowArray, int column) const =0
Unpacks a column into an CoinIndexedvector.
virtual void subsetTimes2(const ClpSimplex *model, CoinIndexedVector *dj1, const CoinIndexedVector *pi2, CoinIndexedVector *dj2, double referenceIn, double devex, unsigned int *reference, double *weights, double scaleFactor)
Updates second array for steepest and does devex weights (need not be coded)
#define COIN_RESTRICT
int trueSequenceOut_
True sequence out (i.e. from larger problem)
Abstract base class for various sparse vectors.
virtual void transposeTimes(double scalar, const double *COIN_RESTRICT x, double *COIN_RESTRICT y) const =0
Return y + x * scalar * A in y.
int originalWanted() const
Initial number of negative reduced costs wanted.
int currentWanted() const
Current number of negative reduced costs which we still need.
void setMinimumObjectsScan(int value)
double CoinFactorizationDouble
Definition: CoinTypes.hpp:57
void setOriginalWanted(int value)
virtual bool allElementsInRange(ClpModel *, double, double, int=15)
Checks if all elements are in valid range.
virtual int hiddenRows() const
Returns number of hidden rows e.g. gub.
virtual void unpackPacked(ClpSimplex *model, CoinIndexedVector *rowArray, int column) const =0
Unpacks a column into an CoinIndexedvector in packed format Note that model is NOT const...
void setType(int newtype)
Sets type.
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:70
virtual void correctSequence(const ClpSimplex *model, int &sequenceIn, int &sequenceOut)
Correct sequence in and out to give true value (if both -1 maybe do whole matrix) ...
Indexed Vector.
double endFraction() const
Current end of search space in matrix (as fraction)
void setStartFraction(double value)
void useEffectiveRhs(ClpSimplex *model)
Sets up an effective RHS.
virtual void subsetTransposeTimes(const ClpSimplex *model, const CoinIndexedVector *x, const CoinIndexedVector *y, CoinIndexedVector *z) const =0
Return x *A in z but just for indices in y.
virtual int refresh(ClpSimplex *)
Purely for column generation and similar ideas.
virtual void setDimensions(int numrows, int numcols)
Set the dimensions of the matrix.
ClpMatrixBase()
Default constructor.
int refreshFrequency_
If rhsOffset used this is refresh frequency (0==off)
virtual void reallyScale(const double *rowScale, const double *columnScale)
virtual void listTransposeTimes(const ClpSimplex *model, double *x, int *y, int number, double *z) const
Return x *A in z but just for number indices in y.
virtual int scale(ClpModel *, const ClpSimplex *=NULL) const
Creates scales for column copy (rowCopy in model may be modified) default does not allow scaling retu...
virtual void scaleRowCopy(ClpModel *) const
Scales rowCopy if column copy scaled Only called if scales already exist.
int lastRefresh_
If rhsOffset used this is iteration last refreshed.
virtual int appendMatrix(int number, int type, const CoinBigIndex *starts, const int *index, const double *element, int numberOther=-1)
Append a set of rows/columns to the end of the matrix.
virtual CoinBigIndex getNumElements() const =0
Number of entries in the packed matrix.
bool skipDualCheck_
whether to skip dual checks most of time
virtual double * rhsOffset(ClpSimplex *model, bool forceRefresh=false, bool check=false)
Returns effective RHS offset if it is being used.
virtual ClpMatrixBase * reverseOrderedCopy() const
Returns a new matrix in reverse order without gaps Is allowed to return NULL if doesn't want to have ...
Sparse Matrix Base Class.
virtual CoinBigIndex * dubiousWeights(const ClpSimplex *model, int *inputWeights) const
Given positive integer weights for each row fills in sum of weights for each column (and slack)...
ClpMatrixBase & operator=(const ClpMatrixBase &)
int CoinBigIndex
virtual ClpMatrixBase * clone() const =0
void setSavedBestDj(double value)
virtual void times(double scalar, const double *COIN_RESTRICT x, double *COIN_RESTRICT y) const =0
Return y + A * x * scalar in y.
int minimumObjectsScan_
Partial pricing tuning parameter - minimum number of "objects" to scan.
virtual const int * getIndices() const =0
A vector containing the minor indices of the elements in the packed matrix.
virtual void backToBasics()
Gets rid of any mutable by products.
virtual int getVectorLength(int index) const
The length of a single major-dimension vector.
int originalWanted_
Initial number of negative reduced costs wanted.
bool skipDualCheck() const
whether to skip dual checks most of time
double CoinWorkDouble
Definition: CoinTypes.hpp:53
virtual ClpMatrixBase * subsetClone(int numberRows, const int *whichRows, int numberColumns, const int *whichColumns) const
Subset clone (without gaps).
int trueSequenceIn_
True sequence in (i.e. from larger problem)
virtual const int * getVectorLengths() const =0
The lengths of the major-dimension vectors.
virtual int checkFeasible(ClpSimplex *model, double &sum) const
Just for debug if odd type matrix.
int type_
type (may be useful)
double startFraction_
Current start of search space in matrix (as fraction)
virtual void releasePackedMatrix() const =0
Allow any parts of a created CoinPackedMatrix to be deleted.
virtual void primalExpanded(ClpSimplex *model, int mode)
utility primal function for dealing with dynamic constraints mode=0 - Set up before "update" and "tim...
virtual int updatePivot(ClpSimplex *model, double oldInValue, double oldOutValue)
update information for a pivot (and effective rhs)
int minimumObjectsScan() const
Partial pricing tuning parameter - minimum number of "objects" to scan.
void setSkipDualCheck(bool yes)
virtual void partialPricing(ClpSimplex *model, double start, double end, int &bestSequence, int &numberWanted)
Partial pricing.
virtual int extendUpdated(ClpSimplex *model, CoinIndexedVector *update, int mode)
expands an updated column to allow for extra rows which the main solver does not know about and retur...
virtual ClpMatrixBase * scaledColumnCopy(ClpModel *) const
Realy really scales column copy Only called if scales already exist.
virtual void createVariable(ClpSimplex *model, int &bestSequence)
Creates a variable.
virtual void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Modify one element of packed matrix.
virtual void deleteCols(const int numDel, const int *indDel)=0
Delete the columns whose indices are listed in indDel.
int minimumGoodReducedCosts_
Partial pricing tuning parameter - minimum number of negative reduced costs to get.
void setEndFraction(double value)
double endFraction_
Current end of search space in matrix (as fraction)
double savedBestDj_
Best reduced cost so far.
void setMinimumGoodReducedCosts(int value)