Clp 1.17.5
Loading...
Searching...
No Matches
ClpPackedMatrix.hpp
Go to the documentation of this file.
1/* $Id: ClpPackedMatrix.hpp 2385 2019-01-06 19:43:06Z unxusr $ */
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 ClpPackedMatrix_H
7#define ClpPackedMatrix_H
8
9#include "CoinPragma.hpp"
10
11#include "ClpMatrixBase.hpp"
13
22class CoinDoubleArrayWithLength;
24
25public:
29 virtual CoinPackedMatrix *getPackedMatrix() const
30 {
31 return matrix_;
32 }
34 virtual bool isColOrdered() const
35 {
36 return matrix_->isColOrdered();
37 }
39 virtual CoinBigIndex getNumElements() const
40 {
41 return matrix_->getNumElements();
42 }
44 virtual int getNumCols() const
45 {
46 return matrix_->getNumCols();
47 }
49 virtual int getNumRows() const
50 {
51 return matrix_->getNumRows();
52 }
53
58 virtual const double *getElements() const
59 {
60 return matrix_->getElements();
61 }
63 inline double *getMutableElements() const
64 {
65 return matrix_->getMutableElements();
66 }
72 virtual const int *getIndices() const
73 {
74 return matrix_->getIndices();
75 }
76
77 virtual const CoinBigIndex *getVectorStarts() const
78 {
79 return matrix_->getVectorStarts();
80 }
82 virtual const int *getVectorLengths() const
83 {
84 return matrix_->getVectorLengths();
85 }
87 virtual int getVectorLength(int index) const
88 {
89 return matrix_->getVectorSize(index);
90 }
91
93 virtual void deleteCols(const int numDel, const int *indDel);
95 virtual void deleteRows(const int numDel, const int *indDel);
96#ifndef CLP_NO_VECTOR
98 virtual void appendCols(int number, const CoinPackedVectorBase *const *columns);
100 virtual void appendRows(int number, const CoinPackedVectorBase *const *rows);
101#endif
106 virtual int appendMatrix(int number, int type,
107 const CoinBigIndex *starts, const int *index,
108 const double *element, int numberOther = -1);
113 virtual void replaceVector(const int index,
114 const int numReplace, const double *newElements)
115 {
116 matrix_->replaceVector(index, numReplace, newElements);
117 }
121 virtual void modifyCoefficient(int row, int column, double newElement,
122 bool keepZero = false)
123 {
124 matrix_->modifyCoefficient(row, column, newElement, keepZero);
125 }
129 virtual int countBasis(const int *whichColumn,
130 int &numberColumnBasic);
132 virtual void fillBasis(ClpSimplex *model,
133 const int *whichColumn,
134 int &numberColumnBasic,
135 int *row, int *start,
136 int *rowCount, int *columnCount,
137 CoinFactorizationDouble *element);
140 virtual int scale(ClpModel *model, ClpSimplex *simplex = NULL) const;
143 virtual void scaleRowCopy(ClpModel *model) const;
145 void createScaledMatrix(ClpSimplex *model) const;
160 virtual bool allElementsInRange(ClpModel *model,
161 double smallest, double largest,
162 int check = 15);
166 virtual void rangeOfElements(double &smallestNegative, double &largestNegative,
167 double &smallestPositive, double &largestPositive);
168
171 virtual void unpack(const ClpSimplex *model, CoinIndexedVector *rowArray,
172 int column) const;
177 virtual void unpackPacked(ClpSimplex *model,
178 CoinIndexedVector *rowArray,
179 int column) const;
182 virtual void add(const ClpSimplex *model, CoinIndexedVector *rowArray,
183 int column, double multiplier) const;
185 virtual void add(const ClpSimplex *model, double *array,
186 int column, double multiplier) const;
188 virtual void releasePackedMatrix() const {}
193 virtual CoinBigIndex *dubiousWeights(const ClpSimplex *model, int *inputWeights) const;
195 virtual bool canDoPartialPricing() const;
197 virtual void partialPricing(ClpSimplex *model, double start, double end,
198 int &bestSequence, int &numberWanted);
200 virtual int refresh(ClpSimplex *model);
201 // Really scale matrix
202 virtual void reallyScale(const double *rowScale, const double *columnScale);
208 virtual void setDimensions(int numrows, int numcols);
210
216 virtual void times(double scalar,
217 const double *x, double *y) const;
219 virtual void times(double scalar,
220 const double *x, double *y,
221 const double *rowScale,
222 const double *columnScale) const;
226 virtual void transposeTimes(double scalar,
227 const double *x, double *y) const;
229 virtual void transposeTimes(double scalar,
230 const double *x, double *y,
231 const double *rowScale,
232 const double *columnScale,
233 double *spare = NULL) const;
238 void transposeTimesSubset(int number,
239 const int *which,
240 const double *pi, double *y,
241 const double *rowScale,
242 const double *columnScale,
243 double *spare = NULL) const;
248 virtual void transposeTimes(const ClpSimplex *model, double scalar,
249 const CoinIndexedVector *x,
250 CoinIndexedVector *y,
251 CoinIndexedVector *z) const;
256 void transposeTimesByColumn(const ClpSimplex *model, double scalar,
257 const CoinIndexedVector *x,
258 CoinIndexedVector *y,
259 CoinIndexedVector *z) const;
265 virtual void transposeTimesByRow(const ClpSimplex *model, double scalar,
266 const CoinIndexedVector *x,
267 CoinIndexedVector *y,
268 CoinIndexedVector *z) const;
272 virtual void subsetTransposeTimes(const ClpSimplex *model,
273 const CoinIndexedVector *x,
274 const CoinIndexedVector *y,
275 CoinIndexedVector *z) const;
278 virtual bool canCombine(const ClpSimplex *model,
279 const CoinIndexedVector *pi) const;
283 virtual int transposeTimes2(const ClpSimplex *model,
284 const CoinIndexedVector *pi1, CoinIndexedVector *dj1,
285 const CoinIndexedVector *pi2,
286 CoinIndexedVector *spare,
287 double *infeas, double *reducedCost,
288 double referenceIn, double devex,
289 // Array for exact devex to say what is in reference framework
290 unsigned int *reference,
291 double *weights, double scaleFactor);
293 virtual void subsetTimes2(const ClpSimplex *model,
294 CoinIndexedVector *dj1,
295 const CoinIndexedVector *pi2, CoinIndexedVector *dj2,
296 double referenceIn, double devex,
297 // Array for exact devex to say what is in reference framework
298 unsigned int *reference,
299 double *weights, double scaleFactor);
302#if COIN_LONG_WORK
303 // For long double versions
304 virtual void times(CoinWorkDouble scalar,
305 const CoinWorkDouble *x, CoinWorkDouble *y) const;
306 virtual void transposeTimes(CoinWorkDouble scalar,
307 const CoinWorkDouble *x, CoinWorkDouble *y) const;
308#endif
310
314 inline CoinPackedMatrix *matrix() const
315 {
316 return matrix_;
317 }
321 inline void setMatrixNull()
322 {
323 matrix_ = NULL;
324 }
327 {
328 flags_ |= 16;
329 }
333 inline bool zeros() const
334 {
335 return ((flags_ & 1) != 0);
336 }
338 inline bool wantsSpecialColumnCopy() const
339 {
340 return ((flags_ & 16) != 0);
341 }
343 inline int flags() const
344 {
345 return flags_;
346 }
348 inline void checkGaps()
349 {
350 flags_ = (matrix_->hasGaps()) ? (flags_ | 2) : (flags_ & (~2));
351 }
353 inline int numberActiveColumns() const
354 {
356 }
358 inline void setNumberActiveColumns(int value)
359 {
360 numberActiveColumns_ = value;
361 }
363
371
377 ClpPackedMatrix(const CoinPackedMatrix &);
381 int numberRows, const int *whichRows,
382 int numberColumns, const int *whichColumns);
383 ClpPackedMatrix(const CoinPackedMatrix &wholeModel,
384 int numberRows, const int *whichRows,
385 int numberColumns, const int *whichColumns);
386
388 ClpPackedMatrix(CoinPackedMatrix *matrix);
389
392 virtual ClpMatrixBase *clone() const;
394 virtual void copy(const ClpPackedMatrix *from);
398 int numberRows, const int *whichRows,
399 int numberColumns, const int *whichColumns) const;
401 void specialRowCopy(ClpSimplex *model, const ClpMatrixBase *rowCopy);
405 virtual void correctSequence(const ClpSimplex *model, int &sequenceIn, int &sequenceOut);
407private:
410 int *COIN_RESTRICT index,
411 double *COIN_RESTRICT array,
412 const double tolerance) const;
415 const double *COIN_RESTRICT columnScale,
416 int *COIN_RESTRICT index,
417 double *COIN_RESTRICT array,
418 const double tolerance) const;
421 int *COIN_RESTRICT index,
422 double *COIN_RESTRICT array,
423 const unsigned char *status,
424 const double tolerance) const;
428 int *COIN_RESTRICT index,
429 double *COIN_RESTRICT array,
430 const unsigned char *status,
431 int *COIN_RESTRICT spareIndex,
432 double *COIN_RESTRICT spareArray,
433 const double *COIN_RESTRICT reducedCost,
434 double &upperTheta,
435 double acceptablePivot,
436 double dualTolerance,
437 int &numberRemaining,
438 const double zeroTolerance) const;
441 const double *COIN_RESTRICT columnScale,
442 int *COIN_RESTRICT index,
443 double *COIN_RESTRICT array,
444 const unsigned char *status,
445 const double tolerance) const;
447 int gutsOfTransposeTimesByRowGEK(const CoinIndexedVector *COIN_RESTRICT piVector,
448 int *COIN_RESTRICT index,
449 double *COIN_RESTRICT output,
450 int numberColumns,
451 const double tolerance,
452 const double scalar) const;
454 int gutsOfTransposeTimesByRowGE3(const CoinIndexedVector *COIN_RESTRICT piVector,
455 int *COIN_RESTRICT index,
456 double *COIN_RESTRICT output,
457 double *COIN_RESTRICT array2,
458 const double tolerance,
459 const double scalar) const;
461 int gutsOfTransposeTimesByRowGE3a(const CoinIndexedVector *COIN_RESTRICT piVector,
462 int *COIN_RESTRICT index,
463 double *COIN_RESTRICT output,
464 int *COIN_RESTRICT lookup,
465 char *COIN_RESTRICT marked,
466 const double tolerance,
467 const double scalar) const;
469 void gutsOfTransposeTimesByRowEQ2(const CoinIndexedVector *piVector, CoinIndexedVector *output,
470 CoinIndexedVector *spareVector, const double tolerance, const double scalar) const;
472 void gutsOfTransposeTimesByRowEQ1(const CoinIndexedVector *piVector, CoinIndexedVector *output,
473 const double tolerance, const double scalar) const;
476
477protected:
479 void checkFlags(int type) const;
484 CoinPackedMatrix *matrix_;
494 mutable int flags_;
500};
501#ifdef THREAD
502#include <pthread.h>
503typedef struct {
504 double acceptablePivot;
505 const ClpSimplex *model;
506 double *spare;
507 int *spareIndex;
508 double *arrayTemp;
509 int *indexTemp;
510 int *numberInPtr;
511 //double * bestPossiblePtr;
512 double *upperThetaPtr;
513 int *posFreePtr;
514 double *freePivotPtr;
515 int *numberOutPtr;
516 const unsigned short *count;
517 const double *pi;
518 const CoinBigIndex *rowStart;
519 const double *element;
520 const unsigned short *column;
521 int offset;
522 int numberInRowArray;
523 int numberLook;
524} dualColumn0Struct;
525#endif
527
528public:
534 void transposeTimes(const ClpSimplex *model,
535 const CoinPackedMatrix *rowCopy,
536 const CoinIndexedVector *x,
537 CoinIndexedVector *spareArray,
538 CoinIndexedVector *z) const;
540 inline bool usefulInfo() const
541 {
542 return rowStart_ != NULL;
543 }
545
551 ClpPackedMatrix2(ClpSimplex *model, const CoinPackedMatrix *rowCopy);
555
562
563protected:
574 mutable unsigned short *count_;
576 mutable CoinBigIndex *rowStart_;
578 unsigned short *column_;
580 double *work_;
581#ifdef THREAD
582 pthread_t *threadId_;
583 dualColumn0Struct *info_;
584#endif
586};
587typedef struct {
588 CoinBigIndex startElements_; // point to data
589 CoinBigIndex startRows_; // point to data later
590 int startIndices_; // point to column_
592 int numberScan_; // i.e. miss out basic and fixed
593 /* order is -
594 free or superbasic
595 at lower
596 at upper
597 fixed or basic */
600 int firstBasic_; // or fixed
601 int numberElements_; // number elements per column
602 int numberOnes_; // later
605
606public:
612 void transposeTimes(const ClpSimplex *model,
613 const double *pi,
614 CoinIndexedVector *output) const;
617 void transposeTimes(const ClpSimplex *model,
618 const double *pi,
619 CoinIndexedVector *output,
620 CoinIndexedVector *candidate,
621 const CoinIndexedVector *rowArray) const;
622 void transposeTimes2(const ClpSimplex *model,
623 const double *pi, CoinIndexedVector *dj1,
624 const double *piWeight,
625 double *COIN_RESTRICT infeas,
626 double *COIN_RESTRICT reducedCost,
627 double referenceIn, double devex,
628 // Array for exact devex to say what is in reference framework
629 unsigned int *reference,
630 double *weights, double scaleFactor);
632
638 ClpPackedMatrix3(ClpSimplex *model, const CoinPackedMatrix *columnCopy);
642
649
652 void sortBlocks(const ClpSimplex *model);
654 void swapOne(const ClpSimplex *model, const ClpPackedMatrix *matrix,
655 int iColumn);
657 void swapOne(int iBlock, int kA, int kB);
659 void checkBlocks(const ClpSimplex *model);
665 ClpPrimalColumnSteepest *pivotChoose,
666 int type);
668
669
670protected:
680#if ABOCA_LITE
682 int numberChunks_;
683#endif
685 CoinBigIndex numberElements_;
691 CoinBigIndex *start_;
693 int *row_;
695 double *element_;
697 CoinDoubleArrayWithLength *temporary_;
698#if ABOCA_LITE
700 int endChunk_[2 * ABOCA_LITE + 1];
701#endif
707};
708#elif INCLUDE_MATRIX3_PRICING
709int iColumn = *column;
710column++;
711if (fabs(value) > zeroTolerance) {
712 double thisWeight = weights[iColumn];
713 double pivot = value * scaleFactor;
714 double pivotSquared = pivot * pivot;
715 thisWeight += pivotSquared * devex + pivot * modification;
716 if (thisWeight < DEVEX_TRY_NORM) {
717 if (referenceIn < 0.0) {
718 // steepest
719 thisWeight = CoinMax(DEVEX_TRY_NORM, DEVEX_ADD_ONE + pivotSquared);
720 } else {
721 // exact
722 thisWeight = referenceIn * pivotSquared;
723 if (reference(iColumn))
724 thisWeight += 1.0;
725 thisWeight = CoinMax(thisWeight, DEVEX_TRY_NORM);
726 }
727 }
728 // out basic or fixed
729 weights[iColumn] = thisWeight;
730 value = reducedCost[iColumn] - value;
731 reducedCost[iColumn] = value;
732 unsigned char thisStatus = status[iColumn] & 7;
733 assert(thisStatus != 0 && thisStatus != 4);
734 if (thisStatus == 3) {
735 //} else if ((thisStatus&1)!=0) {
736 // basic or fixed
737 //value=0.0;
738 } else {
739 assert(thisStatus == 2);
740 value = -value;
741 }
742 if (value < dualTolerance) {
743 value *= value;
744 if (value > bestRatio * weights[iColumn]) {
745 bestSequence = iColumn;
746 bestRatio = value / weights[iColumn];
747#if NO_CHANGE_MULTIPLIER != 1
748 bestRatio2 = bestRatio * NO_CHANGE_MULTIPLIER;
749#endif
750 }
751 }
752} else {
753 // interesting - was faster without this?!
754 value = reducedCost[iColumn];
755 unsigned char thisStatus = status[iColumn] & 7;
756 assert(thisStatus != 0 && thisStatus != 4);
757 if (thisStatus == 3) {
758 } else if ((thisStatus & 1) != 0) {
759 // basic or fixed
760 value = 0.0;
761 } else {
762 value = -value;
763 }
764 if (value < dualTolerance) {
765 value *= value;
766 if (value > bestRatio2 * weights[iColumn]) {
767 bestSequence = iColumn;
768 bestRatio2 = value / weights[iColumn];
769#if NO_CHANGE_MULTIPLIER != 1
770 bestRatio = bestRatio2 * INVERSE_MULTIPLIER;
771#endif
772 }
773 }
774}
775#endif
776
777/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
778*/
#define DEVEX_TRY_NORM
#define DEVEX_ADD_ONE
#define COIN_RESTRICT
Abstract base class for Clp Matrices.
double reducedCost(ClpSimplex *model, int sequence) const
Returns reduced cost of a variable.
int type() const
Returns type.
ClpPackedMatrix2(ClpSimplex *model, const CoinPackedMatrix *rowCopy)
Constructor from copy.
double * work_
work arrays
ClpPackedMatrix2 & operator=(const ClpPackedMatrix2 &)
ClpPackedMatrix2()
Default constructor.
ClpPackedMatrix2(const ClpPackedMatrix2 &)
The copy constructor.
int numberBlocks_
Number of blocks.
void transposeTimes(const ClpSimplex *model, const CoinPackedMatrix *rowCopy, const CoinIndexedVector *x, CoinIndexedVector *spareArray, CoinIndexedVector *z) const
Return x * -1 * A in z.
virtual ~ClpPackedMatrix2()
Destructor.
unsigned short * count_
Counts of elements in each part of row.
int numberRows_
Number of rows.
int * offset_
Column offset for each block (plus one at end)
unsigned short * column_
columns within block
CoinBigIndex * rowStart_
Row starts.
bool usefulInfo() const
Returns true if copy has useful information.
ClpPackedMatrix3 & operator=(const ClpPackedMatrix3 &)
double * element_
Elements.
ClpPackedMatrix3(const ClpPackedMatrix3 &)
The copy constructor.
void transposeTimes2(const ClpSimplex *model, const double *pi, CoinIndexedVector *dj1, const double *piWeight, double *COIN_RESTRICT infeas, double *COIN_RESTRICT reducedCost, double referenceIn, double devex, unsigned int *reference, double *weights, double scaleFactor)
void sortBlocks(const ClpSimplex *model)
Sort blocks.
CoinDoubleArrayWithLength * temporary_
Temporary work area (aligned)
ClpPackedMatrix3()
Default constructor.
blockStruct * block_
Blocks (ordinary start at 0 and go to first block)
ClpPackedMatrix3(ClpSimplex *model, const CoinPackedMatrix *columnCopy)
Constructor from copy.
void transposeTimes(const ClpSimplex *model, const double *pi, CoinIndexedVector *output, CoinIndexedVector *candidate, const CoinIndexedVector *rowArray) const
This version does dualColumn0 Updates two arrays for steepest.
int numberColumnsWithGaps_
Number of columns including gaps.
int maxBlockSize_
Maximum size of any block.
int * column_
Column indices and reverse lookup (within block)
void swapOne(const ClpSimplex *model, const ClpPackedMatrix *matrix, int iColumn)
Swap one variable.
int numberBlocks_
Number of blocks.
void transposeTimes(const ClpSimplex *model, const double *pi, CoinIndexedVector *output) const
Return x * -1 * A in z.
int ifActive_
If active.
int redoInfeasibilities(const ClpSimplex *model, ClpPrimalColumnSteepest *pivotChoose, int type)
type - 1 redo infeasible, 2 choose sequenceIn, 3 both returns sequenceIn (or -1) for type 2
void checkBlocks(const ClpSimplex *model)
Debug - check blocks.
CoinBigIndex numberElements_
Number of elements (including gaps)
int numberColumns_
Number of columns.
CoinBigIndex * start_
Starts for odd/long vectors??
virtual ~ClpPackedMatrix3()
Destructor.
void swapOne(int iBlock, int kA, int kB)
Part of above.
int gutsOfTransposeTimesUnscaled(const double *COIN_RESTRICT pi, int *COIN_RESTRICT index, double *COIN_RESTRICT array, const unsigned char *status, int *COIN_RESTRICT spareIndex, double *COIN_RESTRICT spareArray, const double *COIN_RESTRICT reducedCost, double &upperTheta, double acceptablePivot, double dualTolerance, int &numberRemaining, const double zeroTolerance) const
Meat of transposeTimes by column when not scaled and skipping and doing part of dualColumn.
virtual ~ClpPackedMatrix()
Destructor.
void useEffectiveRhs(ClpSimplex *model)
Sets up an effective RHS.
int gutsOfTransposeTimesByRowGE3a(const CoinIndexedVector *COIN_RESTRICT piVector, int *COIN_RESTRICT index, double *COIN_RESTRICT output, int *COIN_RESTRICT lookup, char *COIN_RESTRICT marked, const double tolerance, const double scalar) const
Meat of transposeTimes by row n > 2 if packed - returns number nonzero.
virtual ClpMatrixBase * clone() const
Clone.
virtual int countBasis(const int *whichColumn, int &numberColumnBasic)
Returns number of elements in column part of basis.
void checkFlags(int type) const
Check validity.
double * getMutableElements() const
Mutable elements.
ClpPackedMatrix(const CoinPackedMatrix &)
The copy constructor from an CoinPackedMatrix.
virtual CoinBigIndex getNumElements() const
Number of entries in the packed matrix.
virtual bool canDoPartialPricing() const
Says whether it can do partial pricing.
virtual void appendCols(int number, const CoinPackedVectorBase *const *columns)
Append Columns.
virtual void appendRows(int number, const CoinPackedVectorBase *const *rows)
Append Rows.
virtual int scale(ClpModel *model, ClpSimplex *simplex=NULL) const
Creates scales for column copy (rowCopy in model may be modified) returns non-zero if no scaling done...
void checkGaps()
Sets flags_ correctly.
virtual void reallyScale(const double *rowScale, const double *columnScale)
bool wantsSpecialColumnCopy() const
Do we want special column copy.
virtual bool allElementsInRange(ClpModel *model, double smallest, double largest, int check=15)
Checks if all elements are in valid range.
bool zeros() const
Are there zeros?
virtual bool isColOrdered() const
Whether the packed matrix is column major ordered or not.
void releaseSpecialColumnCopy()
Say we don't want special column copy.
virtual int getVectorLength(int index) const
The length of a single major-dimension vector.
void gutsOfTransposeTimesByRowEQ2(const CoinIndexedVector *piVector, CoinIndexedVector *output, CoinIndexedVector *spareVector, const double tolerance, const double scalar) const
Meat of transposeTimes by row n == 2 if packed.
virtual void replaceVector(const int index, const int numReplace, const double *newElements)
Replace the elements of a vector.
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.
ClpPackedMatrix(const ClpPackedMatrix &)
The copy constructor.
void setNumberActiveColumns(int value)
Set number of active columns (normally same as number of columns)
void setMatrixNull()
Just sets matrix_ to NULL so it can be used elsewhere.
void clearCopies()
Gets rid of special copies.
virtual void releasePackedMatrix() const
Allow any parts of a created CoinPackedMatrix to be deleted.
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 int transposeTimes2(const ClpSimplex *model, const CoinIndexedVector *pi1, CoinIndexedVector *dj1, const CoinIndexedVector *pi2, CoinIndexedVector *spare, double *infeas, double *reducedCost, double referenceIn, double devex, unsigned int *reference, double *weights, double scaleFactor)
Updates two arrays for steepest and does devex weights Returns nonzero if updates reduced cost and in...
virtual void times(double scalar, const double *x, double *y) const
Return y + A * scalar *x in y.
virtual void copy(const ClpPackedMatrix *from)
Copy contents - resizing if necessary - otherwise re-use memory.
ClpPackedMatrix()
Default constructor.
ClpPackedMatrix(const CoinPackedMatrix &wholeModel, int numberRows, const int *whichRows, int numberColumns, const int *whichColumns)
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 void scaleRowCopy(ClpModel *model) const
Scales rowCopy if column copy scaled Only called if scales already exist.
int flags_
Flags - 1 - has zero elements 2 - has gaps 4 - has special row copy 8 - has special column copy 16 - ...
virtual ClpMatrixBase * subsetClone(int numberRows, const int *whichRows, int numberColumns, const int *whichColumns) const
Subset clone (without gaps).
virtual void partialPricing(ClpSimplex *model, double start, double end, int &bestSequence, int &numberWanted)
Partial pricing.
int gutsOfTransposeTimesUnscaled(const double *COIN_RESTRICT pi, int *COIN_RESTRICT index, double *COIN_RESTRICT array, const double tolerance) const
Meat of transposeTimes by column when not scaled.
virtual void unpack(const ClpSimplex *model, CoinIndexedVector *rowArray, int column) const
Unpacks a column into an CoinIndexedvector.
virtual CoinPackedMatrix * getPackedMatrix() const
Return a complete CoinPackedMatrix.
int gutsOfTransposeTimesScaled(const double *COIN_RESTRICT pi, const double *COIN_RESTRICT columnScale, int *COIN_RESTRICT index, double *COIN_RESTRICT array, const unsigned char *status, const double tolerance) const
Meat of transposeTimes by column when scaled and skipping.
virtual int refresh(ClpSimplex *model)
makes sure active columns correct
void transposeTimesByColumn(const ClpSimplex *model, double scalar, const CoinIndexedVector *x, CoinIndexedVector *y, CoinIndexedVector *z) const
Return x * scalar * A in z.
virtual void deleteCols(const int numDel, const int *indDel)
Delete the columns whose indices are listed in indDel.
virtual void transposeTimes(double scalar, const double *x, double *y, const double *rowScale, const double *columnScale, double *spare=NULL) const
And for scaling.
int gutsOfTransposeTimesUnscaled(const double *COIN_RESTRICT pi, int *COIN_RESTRICT index, double *COIN_RESTRICT array, const unsigned char *status, const double tolerance) const
Meat of transposeTimes by column when not scaled and skipping.
virtual void correctSequence(const ClpSimplex *model, int &sequenceIn, int &sequenceOut)
Correct sequence in and out to give true value.
void makeSpecialColumnCopy()
Say we want special column copy.
void specialColumnCopy(ClpSimplex *model)
make special column copy
ClpPackedMatrix3 * columnCopy_
Special column copy.
virtual void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Modify one element of packed matrix.
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.
virtual void rangeOfElements(double &smallestNegative, double &largestNegative, double &smallestPositive, double &largestPositive)
Returns largest and smallest elements of both signs.
int numberActiveColumns_
number of active columns (normally same as number of columns)
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.
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.
int numberActiveColumns() const
number of active columns (normally same as number of columns)
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).
virtual const CoinBigIndex * getVectorStarts() const
virtual void transposeTimes(double scalar, const double *x, double *y) const
Return y + x * scalar * A in y.
CoinPackedMatrix * matrix() const
Returns CoinPackedMatrix (non const)
virtual void add(const ClpSimplex *model, double *array, int column, double multiplier) const
Adds multiple of a column into an array.
virtual int getNumRows() const
Number of rows.
virtual ClpMatrixBase * scaledColumnCopy(ClpModel *model) const
Realy really scales column copy Only called if scales already exist.
virtual void transposeTimesByRow(const ClpSimplex *model, double scalar, const CoinIndexedVector *x, CoinIndexedVector *y, CoinIndexedVector *z) const
Return x * scalar * A in z.
ClpPackedMatrix(CoinPackedMatrix *matrix)
This takes over ownership (for space reasons)
CoinPackedMatrix * matrix_
Data.
virtual ClpMatrixBase * reverseOrderedCopy() const
Returns a new matrix in reverse order without gaps.
virtual const int * getVectorLengths() const
The lengths of the major-dimension vectors.
virtual const double * getElements() const
A vector containing the elements in the packed matrix.
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.
void specialRowCopy(ClpSimplex *model, const ClpMatrixBase *rowCopy)
make special row copy
ClpPackedMatrix & operator=(const ClpPackedMatrix &)
int flags() const
Flags.
int gutsOfTransposeTimesByRowGE3(const CoinIndexedVector *COIN_RESTRICT piVector, int *COIN_RESTRICT index, double *COIN_RESTRICT output, double *COIN_RESTRICT array2, const double tolerance, const double scalar) const
Meat of transposeTimes by row n > 2 if packed - returns number nonzero.
virtual void setDimensions(int numrows, int numcols)
Set the dimensions of the matrix.
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.
ClpPackedMatrix2 * rowCopy_
Special row copy.
void createScaledMatrix(ClpSimplex *model) const
Creates scaled column copy if scales exist.
virtual void transposeTimes(const ClpSimplex *model, double scalar, const CoinIndexedVector *x, CoinIndexedVector *y, CoinIndexedVector *z) const
Return x * scalar * A in z.
virtual int getNumCols() const
Number of columns.
int gutsOfTransposeTimesByRowGEK(const CoinIndexedVector *COIN_RESTRICT piVector, int *COIN_RESTRICT index, double *COIN_RESTRICT output, int numberColumns, const double tolerance, const double scalar) const
Meat of transposeTimes by row n > K if packed - returns number nonzero.
void gutsOfTransposeTimesByRowEQ1(const CoinIndexedVector *piVector, CoinIndexedVector *output, const double tolerance, const double scalar) const
Meat of transposeTimes by row n == 1 if packed.
virtual void deleteRows(const int numDel, const int *indDel)
Delete the rows whose indices are listed in indDel.
int gutsOfTransposeTimesScaled(const double *COIN_RESTRICT pi, const double *COIN_RESTRICT columnScale, int *COIN_RESTRICT index, double *COIN_RESTRICT array, const double tolerance) const
Meat of transposeTimes by column when scaled.
virtual void times(double scalar, const double *x, double *y, const double *rowScale, const double *columnScale) const
And for scaling.
ClpPackedMatrix(const ClpPackedMatrix &wholeModel, int numberRows, const int *whichRows, int numberColumns, const int *whichColumns)
Subset constructor (without gaps).
virtual const int * getIndices() const
A vector containing the minor indices of the elements in the packed matrix.
Primal Column Pivot Steepest Edge Algorithm Class.
This solves LPs using the simplex method.
CoinBigIndex startRows_
CoinBigIndex startElements_