6 #ifndef ClpPackedMatrix_H 7 #define ClpPackedMatrix_H 9 #include "CoinPragma.hpp" 15 #ifdef COIN_USE_RESTRICT 16 #define COIN_RESTRICT __restrict 45 return matrix_->getNumElements();
65 return matrix_->getMutableElements();
77 return matrix_->getVectorStarts();
81 return matrix_->getVectorLengths();
85 return matrix_->getVectorSize(index);
89 virtual void deleteCols(
const int numDel,
const int * indDel);
91 virtual void deleteRows(
const int numDel,
const int * indDel);
93 virtual void appendCols(
int number,
const CoinPackedVectorBase *
const * columns);
96 virtual void appendRows(
int number,
const CoinPackedVectorBase *
const * rows);
103 const CoinBigIndex * starts,
const int * index,
104 const double * element,
int numberOther = -1);
110 const int numReplace,
const double * newElements) {
111 matrix_->replaceVector(index, numReplace, newElements);
117 bool keepZero =
false) {
118 matrix_->modifyCoefficient(row, column, newElement, keepZero);
123 virtual CoinBigIndex
countBasis(
const int * whichColumn,
124 int & numberColumnBasic);
127 const int * whichColumn,
128 int & numberColumnBasic,
129 int * row,
int * start,
130 int * rowCount,
int * columnCount,
131 CoinFactorizationDouble * element);
155 double smallest,
double largest,
160 virtual void rangeOfElements(
double & smallestNegative,
double & largestNegative,
161 double & smallestPositive,
double & largestPositive);
172 CoinIndexedVector * rowArray,
176 virtual void add(
const ClpSimplex * model, CoinIndexedVector * rowArray,
177 int column,
double multiplier)
const ;
180 int column,
double multiplier)
const;
192 int & bestSequence,
int & numberWanted);
196 virtual void reallyScale(
const double * rowScale,
const double * columnScale);
210 virtual void times(
double scalar,
211 const double * x,
double * y)
const;
213 virtual void times(
double scalar,
214 const double * x,
double * y,
215 const double * rowScale,
216 const double * columnScale)
const;
221 const double * x,
double * y)
const;
224 const double * x,
double * y,
225 const double * rowScale,
226 const double * columnScale,
227 double * spare = NULL)
const;
234 const double * pi,
double * y,
235 const double * rowScale,
236 const double * columnScale,
237 double * spare = NULL)
const;
243 const CoinIndexedVector * x,
244 CoinIndexedVector * y,
245 CoinIndexedVector * z)
const;
251 const CoinIndexedVector * x,
252 CoinIndexedVector * y,
253 CoinIndexedVector * z)
const;
260 const CoinIndexedVector * x,
261 CoinIndexedVector * y,
262 CoinIndexedVector * z)
const;
267 const CoinIndexedVector * x,
268 const CoinIndexedVector * y,
269 CoinIndexedVector * z)
const;
273 const CoinIndexedVector * pi)
const;
276 const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
277 const CoinIndexedVector * pi2,
278 CoinIndexedVector * spare,
279 double referenceIn,
double devex,
281 unsigned int * reference,
282 double * weights,
double scaleFactor);
285 CoinIndexedVector * dj1,
286 const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
287 double referenceIn,
double devex,
289 unsigned int * reference,
290 double * weights,
double scaleFactor);
295 virtual void times(CoinWorkDouble scalar,
296 const CoinWorkDouble * x, CoinWorkDouble * y)
const ;
298 const CoinWorkDouble * x, CoinWorkDouble * y)
const ;
304 inline CoinPackedMatrix *
matrix()
const {
322 return ((
flags_ & 1) != 0);
326 return ((
flags_ & 16) != 0);
362 int numberRows,
const int * whichRows,
363 int numberColumns,
const int * whichColumns);
365 int numberRows,
const int * whichRows,
366 int numberColumns,
const int * whichColumns);
379 int numberRows,
const int * whichRows,
380 int numberColumns,
const int * whichColumns)
const ;
390 int gutsOfTransposeTimesUnscaled(
const double *
COIN_RESTRICT pi,
393 const double tolerance)
const;
395 int gutsOfTransposeTimesScaled(
const double *
COIN_RESTRICT pi,
399 const double tolerance)
const;
401 int gutsOfTransposeTimesUnscaled(
const double *
COIN_RESTRICT pi,
404 const unsigned char * status,
405 const double tolerance)
const;
408 int gutsOfTransposeTimesUnscaled(
const double *
COIN_RESTRICT pi,
411 const unsigned char * status,
416 double & bestPossible,
417 double acceptablePivot,
418 double dualTolerance,
419 int & numberRemaining,
420 const double zeroTolerance)
const;
422 int gutsOfTransposeTimesScaled(
const double *
COIN_RESTRICT pi,
426 const unsigned char * status,
427 const double tolerance)
const;
429 int gutsOfTransposeTimesByRowGEK(
const CoinIndexedVector *
COIN_RESTRICT piVector,
433 const double tolerance,
434 const double scalar)
const;
436 int gutsOfTransposeTimesByRowGE3(
const CoinIndexedVector *
COIN_RESTRICT piVector,
440 const double tolerance,
441 const double scalar)
const;
443 int gutsOfTransposeTimesByRowGE3a(
const CoinIndexedVector *
COIN_RESTRICT piVector,
448 const double tolerance,
449 const double scalar)
const;
451 void gutsOfTransposeTimesByRowEQ2(
const CoinIndexedVector * piVector, CoinIndexedVector * output,
452 CoinIndexedVector * spareVector,
const double tolerance,
const double scalar)
const;
454 void gutsOfTransposeTimesByRowEQ1(
const CoinIndexedVector * piVector, CoinIndexedVector * output,
455 const double tolerance,
const double scalar)
const;
487 double acceptablePivot;
494 double * bestPossiblePtr;
495 double * upperThetaPtr;
497 double * freePivotPtr;
499 const unsigned short * count;
501 const CoinBigIndex * rowStart;
502 const double * element;
503 const unsigned short * column;
505 int numberInRowArray;
518 const CoinPackedMatrix * rowCopy,
519 const CoinIndexedVector * x,
520 CoinIndexedVector * spareArray,
521 CoinIndexedVector * z)
const;
524 return rowStart_ != NULL;
566 pthread_t * threadId_;
567 dualColumn0Struct * info_;
588 CoinIndexedVector * output)
const;
591 const double * pi, CoinIndexedVector * dj1,
592 const double * piWeight,
593 double referenceIn,
double devex,
595 unsigned int * reference,
596 double * weights,
double scaleFactor);
virtual int getNumRows() const
Number of rows.
virtual int scale(ClpModel *model, const ClpSimplex *baseModel=NULL) const
Creates scales for column copy (rowCopy in model may be modified) returns non-zero if no scaling done...
virtual CoinBigIndex getNumElements() const
Number of entries in the packed matrix.
virtual void times(double scalar, const double *x, double *y) const
Return y + A * scalar *x in y.
ClpPackedMatrix3 * columnCopy_
Special column copy.
virtual bool isColOrdered() const
Whether the packed matrix is column major ordered or not.
virtual void replaceVector(const int index, const int numReplace, const double *newElements)
Replace the elements of a vector.
Abstract base class for Clp Matrices.
int flags_
Flags - 1 - has zero elements 2 - has gaps 4 - has special row copy 8 - has special column copy 16 - ...
virtual bool canDoPartialPricing() const
Says whether it can do partial pricing.
void specialRowCopy(ClpSimplex *model, const ClpMatrixBase *rowCopy)
make special row copy
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.
void createScaledMatrix(ClpSimplex *model) const
Creates scaled column copy if scales exist.
virtual void subsetTransposeTimes(const ClpSimplex *model, const CoinIndexedVector *x, const CoinIndexedVector *y, CoinIndexedVector *z) const
Return x *A in z but just for indices in y.
int * offset_
Column offset for each block (plus one at end)
virtual void deleteCols(const int numDel, const int *indDel)
Delete the columns whose indices are listed in indDel.
virtual bool allElementsInRange(ClpModel *model, double smallest, double largest, int check=15)
Checks if all elements are in valid range.
virtual void add(const ClpSimplex *model, CoinIndexedVector *rowArray, int column, double multiplier) const
Adds multiple of a column into an CoinIndexedvector You can use quickAdd to add to vector...
void setMatrixNull()
Just sets matrix_ to NULL so it can be used elsewhere.
virtual void deleteRows(const int numDel, const int *indDel)
Delete the rows whose indices are listed in indDel.
void checkFlags(int type) const
Check validity.
virtual void unpackPacked(ClpSimplex *model, CoinIndexedVector *rowArray, int column) const
Unpacks a column into an CoinIndexedvector in packed foramt Note that model is NOT const...
void setNumberActiveColumns(int value)
Set number of active columns (normally same as number of columns)
int * column_
Column indices and reverse lookup (within block)
bool wantsSpecialColumnCopy() const
Do we want special column copy.
virtual void transposeTimes(double scalar, const double *x, double *y) const
Return y + x * scalar * A in y.
double * element_
Elements.
double reducedCost(ClpSimplex *model, int sequence) const
Returns reduced cost of a variable.
void transposeTimesByColumn(const ClpSimplex *model, double scalar, const CoinIndexedVector *x, CoinIndexedVector *y, CoinIndexedVector *z) const
Return x * scalar * A + y in z.
bool zeros() const
Are there zeros?
virtual void correctSequence(const ClpSimplex *model, int &sequenceIn, int &sequenceOut)
Correct sequence in and out to give true value.
CoinPackedMatrix * matrix_
Data.
virtual const CoinBigIndex * getVectorStarts() const
virtual int getNumCols() const
Number of columns.
unsigned short * column_
columns within block
double * getMutableElements() const
Mutable elements.
virtual void copy(const ClpPackedMatrix *from)
Copy contents - resizing if necessary - otherwise re-use memory.
void specialColumnCopy(ClpSimplex *model)
make special column copy
virtual CoinPackedMatrix * getPackedMatrix() const
Return a complete CoinPackedMatrix.
virtual void fillBasis(ClpSimplex *model, const int *whichColumn, int &numberColumnBasic, int *row, int *start, int *rowCount, int *columnCount, CoinFactorizationDouble *element)
Fills in column part of basis.
This solves LPs using the simplex method.
CoinBigIndex * start_
Starts for odd/long vectors.
virtual const int * getIndices() const
A vector containing the minor indices of the elements in the packed matrix.
ClpPackedMatrix()
Default constructor.
virtual void appendRows(int number, const CoinPackedVectorBase *const *rows)
Append Rows.
virtual void releasePackedMatrix() const
Allow any parts of a created CoinPackedMatrix to be deleted.
virtual const int * getVectorLengths() const
The lengths of the major-dimension vectors.
bool usefulInfo() const
Returns true if copy has useful information.
virtual void scaleRowCopy(ClpModel *model) const
Scales rowCopy if column copy scaled Only called if scales already exist.
virtual const double * getElements() const
A vector containing the elements in the packed matrix.
virtual void rangeOfElements(double &smallestNegative, double &largestNegative, double &smallestPositive, double &largestPositive)
Returns largest and smallest elements of both signs.
virtual CoinBigIndex countBasis(const int *whichColumn, int &numberColumnBasic)
Returns number of elements in column part of basis.
void checkGaps()
Sets flags_ correctly.
int numberActiveColumns_
number of active columns (normally same as number of columns)
virtual ClpMatrixBase * reverseOrderedCopy() const
Returns a new matrix in reverse order without gaps.
virtual void reallyScale(const double *rowScale, const double *columnScale)
int type() const
Returns type.
virtual void appendCols(int number, const CoinPackedVectorBase *const *columns)
Append Columns.
ClpPackedMatrix & operator=(const ClpPackedMatrix &)
int numberColumns_
Number of columns.
virtual void transposeTimesByRow(const ClpSimplex *model, double scalar, const CoinIndexedVector *x, CoinIndexedVector *y, CoinIndexedVector *z) const
Return x * scalar * A + y in z.
virtual void partialPricing(ClpSimplex *model, double start, double end, int &bestSequence, int &numberWanted)
Partial pricing.
void transposeTimesSubset(int number, const int *which, const double *pi, double *y, const double *rowScale, const double *columnScale, double *spare=NULL) const
Return y - pi * A in y.
unsigned short * count_
Counts of elements in each part of row.
CoinBigIndex startElements_
virtual void unpack(const ClpSimplex *model, CoinIndexedVector *rowArray, int column) const
Unpacks a column into an CoinIndexedvector.
virtual bool canCombine(const ClpSimplex *model, const CoinIndexedVector *pi) const
Returns true if can combine transposeTimes and subsetTransposeTimes and if it would be faster...
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)...
int numberActiveColumns() const
number of active columns (normally same as number of columns)
virtual void setDimensions(int numrows, int numcols)
Set the dimensions of the matrix.
virtual ClpMatrixBase * scaledColumnCopy(ClpModel *model) const
Realy really scales column copy Only called if scales already exist.
virtual ClpMatrixBase * clone() const
Clone.
void releaseSpecialColumnCopy()
Say we don't want special column copy.
void useEffectiveRhs(ClpSimplex *model)
Sets up an effective RHS.
virtual ~ClpPackedMatrix()
Destructor.
int numberRows_
Number of rows.
virtual int getVectorLength(int index) const
The length of a single major-dimension vector.
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.
virtual void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Modify one element of packed matrix.
virtual int refresh(ClpSimplex *model)
makes sure active columns correct
ClpPackedMatrix2 * rowCopy_
Special row copy.
double * work_
work arrays
CoinBigIndex * rowStart_
Row starts.
blockStruct * block_
Blocks (ordinary start at 0 and go to first block)
CoinPackedMatrix * matrix() const
Returns CoinPackedMatrix (non const)
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.
virtual ClpMatrixBase * subsetClone(int numberRows, const int *whichRows, int numberColumns, const int *whichColumns) const
Subset clone (without gaps).
void makeSpecialColumnCopy()
Say we want special column copy.