00001
00002
00003
00004
00005
00006 #ifndef AbcMatrix_H
00007 #define AbcMatrix_H
00008
00009 #include "CoinPragma.hpp"
00010
00011 #include "ClpMatrixBase.hpp"
00012 #include "AbcSimplex.hpp"
00013 #include "CoinAbcHelperFunctions.hpp"
00020 class AbcMatrix2;
00021 class AbcMatrix3;
00022 class AbcMatrix {
00023
00024 public:
00027
00028 inline CoinPackedMatrix * getPackedMatrix() const {
00029 return matrix_;
00030 }
00032 inline bool isColOrdered() const {
00033 return true;
00034 }
00036 inline CoinBigIndex getNumElements() const {
00037 return matrix_->getNumElements();
00038 }
00040 inline int getNumCols() const {
00041 assert(matrix_->getNumCols()==model_->numberColumns());return matrix_->getNumCols();
00042 }
00044 inline int getNumRows() const {
00045 assert(matrix_->getNumRows()==model_->numberRows());return matrix_->getNumRows();
00046 }
00048 void setModel(AbcSimplex * model);
00050 inline const double * getElements() const {
00051 return matrix_->getElements();
00052 }
00054 inline double * getMutableElements() const {
00055 return matrix_->getMutableElements();
00056 }
00058 inline const int * getIndices() const {
00059 return matrix_->getIndices();
00060 }
00062 inline int * getMutableIndices() const {
00063 return matrix_->getMutableIndices();
00064 }
00066 inline const CoinBigIndex * getVectorStarts() const {
00067 return matrix_->getVectorStarts();
00068 }
00069 inline CoinBigIndex * getMutableVectorStarts() const {
00070 return matrix_->getMutableVectorStarts();
00071 }
00073 inline const int * getVectorLengths() const {
00074 return matrix_->getVectorLengths();
00075 }
00077 inline int * getMutableVectorLengths() const {
00078 return matrix_->getMutableVectorLengths();
00079 }
00081 CoinBigIndex * rowStart() const;
00083 CoinBigIndex * rowEnd() const;
00085 double * rowElements() const;
00087 CoinSimplexInt * rowColumns() const;
00089 CoinPackedMatrix * reverseOrderedCopy() const;
00091 CoinBigIndex countBasis(const int * whichColumn,
00092 int & numberColumnBasic);
00094 void fillBasis(const int * whichColumn,
00095 int & numberColumnBasic,
00096 int * row, int * start,
00097 int * rowCount, int * columnCount,
00098 CoinSimplexDouble * element);
00100 void fillBasis(const int * whichColumn,
00101 int & numberColumnBasic,
00102 int * row, int * start,
00103 int * rowCount, int * columnCount,
00104 long double * element);
00107 void scale(int numberRowsAlreadyScaled);
00109 void createRowCopy();
00111 void takeOutOfUseful(int sequence,CoinIndexedVector & spare);
00113 void putIntofUseful(int sequence,CoinIndexedVector & spare);
00115 void inOutUseful(int sequenceIn,int sequenceOut);
00117 void makeAllUseful(CoinIndexedVector & spare);
00119 void sortUseful(CoinIndexedVector & spare);
00121 void moveLargestToStart();
00122
00125 void unpack(CoinIndexedVector & rowArray,
00126 int column) const ;
00129 void add(CoinIndexedVector & rowArray, int column, double multiplier) const ;
00131
00137 void timesModifyExcludingSlacks(double scalar,
00138 const double * x, double * y) const;
00142 void timesModifyIncludingSlacks(double scalar,
00143 const double * x, double * y) const;
00147 void timesIncludingSlacks(double scalar,
00148 const double * x, double * y) const;
00152 void transposeTimesNonBasic(double scalar,
00153 const double * x, double * y) const;
00157 void transposeTimesAll(const double * x, double * y) const;
00161 void transposeTimesBasic(double scalar,
00162 const double * x, double * y) const;
00173 int transposeTimesNonBasic(double scalar,
00174 const CoinIndexedVector & x,
00175 CoinIndexedVector & z) const;
00177 double dualColumn1(const CoinIndexedVector & update,
00178 CoinPartitionedVector & tableauRow,
00179 CoinPartitionedVector & candidateList) const;
00181 double dualColumn1Row(int iBlock, double upperThetaSlack, int & freeSequence,
00182 const CoinIndexedVector & update,
00183 CoinPartitionedVector & tableauRow,
00184 CoinPartitionedVector & candidateList) const;
00186 double dualColumn1RowFew(int iBlock, double upperThetaSlack, int & freeSequence,
00187 const CoinIndexedVector & update,
00188 CoinPartitionedVector & tableauRow,
00189 CoinPartitionedVector & candidateList) const;
00191 double dualColumn1Row2(double upperThetaSlack, int & freeSequence,
00192 const CoinIndexedVector & update,
00193 CoinPartitionedVector & tableauRow,
00194 CoinPartitionedVector & candidateList) const;
00196 double dualColumn1Row1(double upperThetaSlack, int & freeSequence,
00197 const CoinIndexedVector & update,
00198 CoinPartitionedVector & tableauRow,
00199 CoinPartitionedVector & candidateList) const;
00203 void dualColumn1Part(int iBlock,int & sequenceIn, double & upperTheta,
00204 const CoinIndexedVector & update,
00205 CoinPartitionedVector & tableauRow,
00206 CoinPartitionedVector & candidateList) const;
00208 void rebalance() const;
00210 int pivotColumnDantzig(const CoinIndexedVector & updates,
00211 CoinPartitionedVector & spare) const;
00213 int pivotColumnDantzig(int iBlock,bool doByRow,const CoinIndexedVector & updates,
00214 CoinPartitionedVector & spare,
00215 double & bestValue) const;
00217 int primalColumnRow(int iBlock,bool doByRow,const CoinIndexedVector & update,
00218 CoinPartitionedVector & tableauRow) const;
00220 int primalColumnRowAndDjs(int iBlock,const CoinIndexedVector & updateTableau,
00221 const CoinIndexedVector & updateDjs,
00222 CoinPartitionedVector & tableauRow) const;
00225 int chooseBestDj(int iBlock,const CoinIndexedVector & infeasibilities,
00226 const double * weights) const;
00232 int primalColumnDouble(int iBlock,CoinPartitionedVector & updateForTableauRow,
00233 CoinPartitionedVector & updateForDjs,
00234 const CoinIndexedVector & updateForWeights,
00235 CoinPartitionedVector & spareColumn1,
00236 double * infeasibilities,
00237 double referenceIn, double devex,
00238
00239 unsigned int * reference,
00240 double * weights, double scaleFactor) const;
00246 int primalColumnSparseDouble(int iBlock,CoinPartitionedVector & updateForTableauRow,
00247 CoinPartitionedVector & updateForDjs,
00248 const CoinIndexedVector & updateForWeights,
00249 CoinPartitionedVector & spareColumn1,
00250 double * infeasibilities,
00251 double referenceIn, double devex,
00252
00253 unsigned int * reference,
00254 double * weights, double scaleFactor) const;
00260 int primalColumnDouble(CoinPartitionedVector & updateForTableauRow,
00261 CoinPartitionedVector & updateForDjs,
00262 const CoinIndexedVector & updateForWeights,
00263 CoinPartitionedVector & spareColumn1,
00264 CoinIndexedVector & infeasible,
00265 double referenceIn, double devex,
00266
00267 unsigned int * reference,
00268 double * weights, double scaleFactor) const;
00270 void primalColumnSubset(int iBlock,const CoinIndexedVector & update,
00271 const CoinPartitionedVector & tableauRow,
00272 CoinPartitionedVector & weights) const;
00274 void partialPricing(double startFraction, double endFraction,
00275 int & bestSequence, int & numberWanted);
00279 void subsetTransposeTimes(const CoinIndexedVector & x,
00280 CoinIndexedVector & z) const;
00282 void transposeTimes(const CoinIndexedVector & x,
00283 CoinIndexedVector & z) const;
00285
00288
00289 inline CoinPackedMatrix * matrix() const {
00290 return matrix_;
00291 }
00294 inline int minimumObjectsScan() const {
00295 return minimumObjectsScan_;
00296 }
00297 inline void setMinimumObjectsScan(int value) {
00298 minimumObjectsScan_ = value;
00299 }
00301 inline int minimumGoodReducedCosts() const {
00302 return minimumGoodReducedCosts_;
00303 }
00304 inline void setMinimumGoodReducedCosts(int value) {
00305 minimumGoodReducedCosts_ = value;
00306 }
00308 inline double startFraction() const {
00309 return startFraction_;
00310 }
00311 inline void setStartFraction(double value) {
00312 startFraction_ = value;
00313 }
00315 inline double endFraction() const {
00316 return endFraction_;
00317 }
00318 inline void setEndFraction(double value) {
00319 endFraction_ = value;
00320 }
00322 inline double savedBestDj() const {
00323 return savedBestDj_;
00324 }
00325 inline void setSavedBestDj(double value) {
00326 savedBestDj_ = value;
00327 }
00329 inline int originalWanted() const {
00330 return originalWanted_;
00331 }
00332 inline void setOriginalWanted(int value) {
00333 originalWanted_ = value;
00334 }
00336 inline int currentWanted() const {
00337 return currentWanted_;
00338 }
00339 inline void setCurrentWanted(int value) {
00340 currentWanted_ = value;
00341 }
00343 inline int savedBestSequence() const {
00344 return savedBestSequence_;
00345 }
00346 inline void setSavedBestSequence(int value) {
00347 savedBestSequence_ = value;
00348 }
00350 inline int * startColumnBlock() const
00351 {return startColumnBlock_;}
00353 inline const int * blockStart() const
00354 { return blockStart_;}
00355 inline bool gotRowCopy() const
00356 { return rowStart_!=0;}
00358 inline int blockStart(int block) const
00359 { return blockStart_[block];}
00361 inline int numberColumnBlocks() const
00362 { return numberColumnBlocks_;}
00364 inline int numberRowBlocks() const
00365 { return numberRowBlocks_;}
00367
00368
00372 AbcMatrix();
00374 ~AbcMatrix();
00376
00380 AbcMatrix(const AbcMatrix&);
00382 AbcMatrix(const CoinPackedMatrix&);
00385 AbcMatrix (const AbcMatrix & wholeModel,
00386 int numberRows, const int * whichRows,
00387 int numberColumns, const int * whichColumns);
00388 AbcMatrix (const CoinPackedMatrix & wholeModel,
00389 int numberRows, const int * whichRows,
00390 int numberColumns, const int * whichColumns);
00391
00392 AbcMatrix& operator=(const AbcMatrix&);
00394 void copy(const AbcMatrix * from);
00396 private:
00397
00398 protected:
00402
00403 CoinPackedMatrix * matrix_;
00405 mutable AbcSimplex * model_;
00406 #if ABC_PARALLEL==0
00407 #define NUMBER_ROW_BLOCKS 1
00408 #define NUMBER_COLUMN_BLOCKS 1
00409 #elif ABC_PARALLEL==1
00410 #define NUMBER_ROW_BLOCKS 4
00411 #define NUMBER_COLUMN_BLOCKS 4
00412 #else
00413 #define NUMBER_ROW_BLOCKS 8
00414 #define NUMBER_COLUMN_BLOCKS 8
00415 #endif
00416
00419 CoinBigIndex * rowStart_;
00421 double * element_;
00423 int * column_;
00425 mutable int startColumnBlock_[NUMBER_COLUMN_BLOCKS+1];
00427 int blockStart_[NUMBER_ROW_BLOCKS+1];
00429 mutable int numberColumnBlocks_;
00431 int numberRowBlocks_;
00432
00433 #ifdef COUNT_COPY
00434 #define MAX_COUNT 13
00436 CoinBigIndex countStart_[MAX_COUNT+1];
00438 int countFirst_[MAX_COUNT+1];
00439
00440 int * countRealColumn_;
00441
00442 CoinBigIndex * countStartLarge_;
00443 int * countRow_;
00444 double * countElement_;
00445 int smallestCount_;
00446 int largestCount_;
00447 #endif
00449 //AbcMatrix2 * rowCopy_;
00451 //AbcMatrix3 * columnCopy_;
00453 double startFraction_;
00455 double endFraction_;
00457 double savedBestDj_;
00459 int originalWanted_;
00461 int currentWanted_;
00463 int savedBestSequence_;
00465 int minimumObjectsScan_;
00467 int minimumGoodReducedCosts_;
00468
00469 };
00470 #ifdef THREAD
00471 #include <pthread.h>
00472 typedef struct {
00473 double acceptablePivot;
00474 const AbcSimplex * model;
00475 double * spare;
00476 int * spareIndex;
00477 double * arrayTemp;
00478 int * indexTemp;
00479 int * numberInPtr;
00480 double * bestPossiblePtr;
00481 double * upperThetaPtr;
00482 int * posFreePtr;
00483 double * freePivotPtr;
00484 int * numberOutPtr;
00485 const unsigned short * count;
00486 const double * pi;
00487 const CoinBigIndex * rowStart;
00488 const double * element;
00489 const unsigned short * column;
00490 int offset;
00491 int numberInRowArray;
00492 int numberLook;
00493 } dualColumn0Struct;
00494 #endif
00495 class AbcMatrix2 {
00496
00497 public:
00503 void transposeTimes(const AbcSimplex * model,
00504 const CoinPackedMatrix * rowCopy,
00505 const CoinIndexedVector & x,
00506 CoinIndexedVector & spareArray,
00507 CoinIndexedVector & z) const;
00509 inline bool usefulInfo() const {
00510 return rowStart_ != NULL;
00511 }
00513
00514
00518 AbcMatrix2();
00520 AbcMatrix2(AbcSimplex * model, const CoinPackedMatrix * rowCopy);
00522 ~AbcMatrix2();
00524
00528 AbcMatrix2(const AbcMatrix2&);
00529 AbcMatrix2& operator=(const AbcMatrix2&);
00531
00532
00533 protected:
00537
00538 int numberBlocks_;
00540 int numberRows_;
00542 int * offset_;
00544 mutable unsigned short * count_;
00546 mutable CoinBigIndex * rowStart_;
00548 unsigned short * column_;
00550 double * work_;
00551 #ifdef THREAD
00552 pthread_t * threadId_;
00553 dualColumn0Struct * info_;
00554 #endif
00555
00556 };
00557 typedef struct {
00558 CoinBigIndex startElements_;
00559 int startIndices_;
00560 int numberInBlock_;
00561 int numberPrice_;
00562 int numberElements_;
00563 } blockStruct3;
00564 class AbcMatrix3 {
00565
00566 public:
00572 void transposeTimes(const AbcSimplex * model,
00573 const double * pi,
00574 CoinIndexedVector & output) const;
00576 void transposeTimes2(const AbcSimplex * model,
00577 const double * pi, CoinIndexedVector & dj1,
00578 const double * piWeight,
00579 double referenceIn, double devex,
00580
00581 unsigned int * reference,
00582 double * weights, double scaleFactor);
00584
00585
00589 AbcMatrix3();
00591 AbcMatrix3(AbcSimplex * model, const CoinPackedMatrix * columnCopy);
00593 ~AbcMatrix3();
00595
00599 AbcMatrix3(const AbcMatrix3&);
00600 AbcMatrix3& operator=(const AbcMatrix3&);
00602
00605 void sortBlocks(const AbcSimplex * model);
00607 void swapOne(const AbcSimplex * model, const AbcMatrix * matrix,
00608 int iColumn);
00610
00611
00612 protected:
00616
00617 int numberBlocks_;
00619 int numberColumns_;
00621 int * column_;
00623 CoinBigIndex * start_;
00625 int * row_;
00627 double * element_;
00629 blockStruct * block_;
00631 };
00632
00633 #endif