#include <CoinFactorization.hpp>
Collaboration diagram for CoinFactorization:
used by factorization | |
| void | getAreas (int numberRows, int numberColumns, CoinBigIndex maximumL, CoinBigIndex maximumU) |
| Gets space for a factorization, called by constructors. | |
| void | preProcess (int state, int possibleDuplicates=-1) |
| PreProcesses raw triplet data. | |
| int | factor () |
| Does most of factorization. | |
| int | replaceColumnPFI (CoinIndexedVector *regionSparse, int pivotRow, double alpha) |
| Replaces one Column to basis for PFI returns 0=OK, 1=Probably OK, 2=singular, 3=no room. | |
| int | factorSparse () |
| Does sparse phase of factorization return code is <0 error, 0= finished. | |
| int | factorSparseSmall () |
| Does sparse phase of factorization (for smaller problems) return code is <0 error, 0= finished. | |
| int | factorSparseLarge () |
| Does sparse phase of factorization (for larger problems) return code is <0 error, 0= finished. | |
| int | factorDense () |
| Does dense phase of factorization return code is <0 error, 0= finished. | |
| bool | pivotOneOtherRow (int pivotRow, int pivotColumn) |
| Pivots when just one other row so faster? | |
| bool | pivotRowSingleton (int pivotRow, int pivotColumn) |
| Does one pivot on Row Singleton in factorization. | |
| bool | pivotColumnSingleton (int pivotRow, int pivotColumn) |
| Does one pivot on Column Singleton in factorization. | |
| bool | getColumnSpace (int iColumn, int extraNeeded) |
| Gets space for one Column with given length, may have to do compression (returns True if successful), also moves existing vector, extraNeeded is over and above present. | |
| bool | getColumnSpaceIterateR (int iColumn, double value, int iRow) |
| getColumnSpaceIterateR. | |
| CoinBigIndex | getColumnSpaceIterate (int iColumn, double value, int iRow) |
| getColumnSpaceIterate. | |
| bool | getRowSpace (int iRow, int extraNeeded) |
| Gets space for one Row with given length, may have to do compression (returns True if successful), also moves existing vector. | |
| bool | getRowSpaceIterate (int iRow, int extraNeeded) |
| Gets space for one Row with given length while iterating, may have to do compression (returns True if successful), also moves existing vector. | |
| void | checkConsistency () |
| Checks that row and column copies look OK. | |
| void | addLink (int index, int count) |
| Adds a link in chain of equal counts. | |
| void | deleteLink (int index) |
| Deletes a link in chain of equal counts. | |
| void | separateLinks (int count, bool rowsFirst) |
| Separate out links with same row/column count. | |
| void | cleanup () |
| Cleans up at end of factorization. | |
| void | updateColumnL (CoinIndexedVector *region, int *indexIn) const |
| Updates part of column (FTRANL). | |
| void | updateColumnLDensish (CoinIndexedVector *region, int *indexIn) const |
| Updates part of column (FTRANL) when densish. | |
| void | updateColumnLSparse (CoinIndexedVector *region, int *indexIn) const |
| Updates part of column (FTRANL) when sparse. | |
| void | updateColumnLSparsish (CoinIndexedVector *region, int *indexIn) const |
| Updates part of column (FTRANL) when sparsish. | |
| void | updateColumnR (CoinIndexedVector *region) const |
| Updates part of column (FTRANR) without FT update. | |
| void | updateColumnRFT (CoinIndexedVector *region, int *indexIn) |
| Updates part of column (FTRANR) with FT update. | |
| void | updateColumnU (CoinIndexedVector *region, int *indexIn) const |
| Updates part of column (FTRANU). | |
| void | updateColumnUSparse (CoinIndexedVector *regionSparse, int *indexIn) const |
| Updates part of column (FTRANU) when sparse. | |
| void | updateColumnUSparsish (CoinIndexedVector *regionSparse, int *indexIn) const |
| Updates part of column (FTRANU) when sparsish. | |
| int | updateColumnUDensish (double *COIN_RESTRICT region, int *COIN_RESTRICT regionIndex) const |
| Updates part of column (FTRANU). | |
| void | updateTwoColumnsUDensish (int &numberNonZero1, double *COIN_RESTRICT region1, int *COIN_RESTRICT index1, int &numberNonZero2, double *COIN_RESTRICT region2, int *COIN_RESTRICT index2) const |
| Updates part of 2 columns (FTRANU) real work. | |
| void | updateColumnPFI (CoinIndexedVector *regionSparse) const |
| Updates part of column PFI (FTRAN) (after rest). | |
| void | permuteBack (CoinIndexedVector *regionSparse, CoinIndexedVector *outVector) const |
| Permutes back at end of updateColumn. | |
| void | updateColumnTransposePFI (CoinIndexedVector *region) const |
| Updates part of column transpose PFI (BTRAN) (before rest). | |
| void | updateColumnTransposeU (CoinIndexedVector *region, int smallestIndex) const |
| Updates part of column transpose (BTRANU), assumes index is sorted i.e. | |
| void | updateColumnTransposeUSparsish (CoinIndexedVector *region, int smallestIndex) const |
| Updates part of column transpose (BTRANU) when sparsish, assumes index is sorted i.e. | |
| void | updateColumnTransposeUDensish (CoinIndexedVector *region, int smallestIndex) const |
| Updates part of column transpose (BTRANU) when densish, assumes index is sorted i.e. | |
| void | updateColumnTransposeUSparse (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANU) when sparse, assumes index is sorted i.e. | |
| void | updateColumnTransposeR (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANR). | |
| void | updateColumnTransposeRDensish (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANR) when dense. | |
| void | updateColumnTransposeRSparse (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANR) when sparse. | |
| void | updateColumnTransposeL (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANL). | |
| void | updateColumnTransposeLDensish (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANL) when densish by column. | |
| void | updateColumnTransposeLByRow (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANL) when densish by row. | |
| void | updateColumnTransposeLSparsish (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANL) when sparsish by row. | |
| void | updateColumnTransposeLSparse (CoinIndexedVector *region) const |
| Updates part of column transpose (BTRANL) when sparse (by Row). | |
| int | checkPivot (double saveFromU, double oldPivot) const |
| Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular. | |
| template<class T> | |
| bool | pivot (int pivotRow, int pivotColumn, CoinBigIndex pivotRowPosition, CoinBigIndex pivotColumnPosition, double work[], unsigned int workArea2[], int increment, int increment2, T markRow[], int largeInteger) |
| Gets space for a factorization, called by constructors. | |
Public Member Functions | |
Constructors and destructor and copy | |
| CoinFactorization () | |
| Default constructor. | |
| CoinFactorization (const CoinFactorization &other) | |
| Copy constructor. | |
| ~CoinFactorization () | |
| Destructor. | |
| void | almostDestructor () |
| Delete all stuff (leaves as after CoinFactorization()). | |
| void | show_self () const |
| Debug show object (shows one representation). | |
| int | saveFactorization (const char *file) const |
| Debug - save on file - 0 if no error. | |
| int | restoreFactorization (const char *file, bool factor=false) |
| Debug - restore from file - 0 if no error on file. | |
| void | sort () const |
| Debug - sort so can compare. | |
| CoinFactorization & | operator= (const CoinFactorization &other) |
| = copy | |
Do factorization | |
| int | factorize (const CoinPackedMatrix &matrix, int rowIsBasic[], int columnIsBasic[], double areaFactor=0.0) |
| When part of LP - given by basic variables. | |
| int | factorize (int numberRows, int numberColumns, CoinBigIndex numberElements, CoinBigIndex maximumL, CoinBigIndex maximumU, const int indicesRow[], const int indicesColumn[], const double elements[], int permutation[], double areaFactor=0.0) |
| When given as triplets. | |
| int | factorizePart1 (int numberRows, int numberColumns, CoinBigIndex estimateNumberElements, int *indicesRow[], int *indicesColumn[], double *elements[], double areaFactor=0.0) |
| Two part version for maximum flexibility This part creates arrays for user to fill. | |
| int | factorizePart2 (int permutation[], int exactNumberElements) |
| This is part two of factorization Arrays belong to factorization and were returned by part 1 If status okay, permutation has pivot rows - this is only needed If status is singular, then basic variables have pivot row and ones thrown out have -1 returns 0 -okay, -1 singular, -99 memory. | |
| double | conditionNumber () const |
| Condition number - product of pivots after factorization. | |
general stuff such as permutation or status | |
| int | status () const |
| Returns status. | |
| void | setStatus (int value) |
| Sets status. | |
| int | pivots () const |
| Returns number of pivots since factorization. | |
| void | setPivots (int value) |
| Sets number of pivots since factorization. | |
| int * | permute () const |
| Returns address of permute region. | |
| int * | pivotColumn () const |
| Returns address of pivotColumn region (also used for permuting). | |
| double * | pivotRegion () const |
| Returns address of pivot region. | |
| int * | permuteBack () const |
| Returns address of permuteBack region. | |
| int * | pivotColumnBack () const |
| Returns address of pivotColumnBack region (also used for permuting). | |
| CoinBigIndex * | startRowL () const |
| Start of each row in L. | |
| CoinBigIndex * | startColumnL () const |
| Start of each column in L. | |
| int * | indexColumnL () const |
| Index of column in row for L. | |
| int * | indexRowL () const |
| Row indices of L. | |
| double * | elementByRowL () const |
| Elements in L (row copy). | |
| int | numberRowsExtra () const |
| Number of Rows after iterating. | |
| void | setNumberRows (int value) |
| Set number of Rows after factorization. | |
| int | numberRows () const |
| Number of Rows after factorization. | |
| CoinBigIndex | numberL () const |
| Number in L. | |
| CoinBigIndex | baseL () const |
| Base of L. | |
| int | maximumRowsExtra () const |
| Maximum of Rows after iterating. | |
| int | numberColumns () const |
| Total number of columns in factorization. | |
| int | numberElements () const |
| Total number of elements in factorization. | |
| int | numberForrestTomlin () const |
| Length of FT vector. | |
| int | numberGoodColumns () const |
| Number of good columns in factorization. | |
| double | areaFactor () const |
| Whether larger areas needed. | |
| void | areaFactor (double value) |
| Returns status. | |
| double | adjustedAreaFactor () const |
| Returns areaFactor but adjusted for dense. | |
| void | relaxAccuracyCheck (double value) |
| Allows change of pivot accuracy check 1.0 == none >1.0 relaxed. | |
| double | getAccuracyCheck () const |
| Returns status. | |
| int | messageLevel () const |
| Level of detail of messages. | |
| void | messageLevel (int value) |
| Returns status. | |
| int | maximumPivots () const |
| Maximum number of pivots between factorizations. | |
| void | maximumPivots (int value) |
| Returns status. | |
| int | denseThreshold () const |
| Gets dense threshold. | |
| void | setDenseThreshold (int value) |
| Sets dense threshold. | |
| double | pivotTolerance () const |
| Pivot tolerance. | |
| void | pivotTolerance (double value) |
| Returns status. | |
| double | zeroTolerance () const |
| Zero tolerance. | |
| void | zeroTolerance (double value) |
| Returns status. | |
| double | slackValue () const |
| Whether slack value is +1 or -1. | |
| void | slackValue (double value) |
| Returns status. | |
| double | maximumCoefficient () const |
| Returns maximum absolute value in factorization. | |
| bool | forrestTomlin () const |
| true if Forrest Tomlin update, false if PFI | |
| void | setForrestTomlin (bool value) |
| Returns status. | |
| bool | spaceForForrestTomlin () const |
| True if FT update and space. | |
some simple stuff | |
| int | numberDense () const |
| Returns number of dense rows. | |
| CoinBigIndex | numberElementsU () const |
| Returns number in U area. | |
| void | setNumberElementsU (CoinBigIndex value) |
| Setss number in U area. | |
| CoinBigIndex | lengthAreaU () const |
| Returns length of U area. | |
| CoinBigIndex | numberElementsL () const |
| Returns number in L area. | |
| CoinBigIndex | lengthAreaL () const |
| Returns length of L area. | |
| CoinBigIndex | numberElementsR () const |
| Returns number in R area. | |
| CoinBigIndex | numberCompressions () const |
| Number of compressions done. | |
| int * | numberInRow () const |
| Number of entries in each row. | |
| int * | numberInColumn () const |
| Number of entries in each column. | |
| double * | elementU () const |
| Elements of U. | |
| int * | indexRowU () const |
| Row indices of U. | |
| CoinBigIndex * | startColumnU () const |
| Start of each column in U. | |
| int | maximumColumnsExtra () |
| Maximum number of Columns after iterating. | |
| int | biasLU () const |
| L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias. | |
| void | setBiasLU (int value) |
| Returns number of dense rows. | |
| int | persistenceFlag () const |
| Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 but give a bit extra if bigger needed. | |
| void | setPersistenceFlag (int value) |
| Returns number of dense rows. | |
rank one updates which do exist | |
| int | replaceColumn (CoinIndexedVector *regionSparse, int pivotRow, double pivotCheck, bool checkBeforeModifying=false) |
| Replaces one Column to basis, returns 0=OK, 1=Probably OK, 2=singular, 3=no room If checkBeforeModifying is true will do all accuracy checks before modifying factorization. | |
various uses of factorization (return code number elements) | |
which user may want to know about | |
| int | updateColumnFT (CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) |
| Updates one column (FTRAN) from regionSparse2 Tries to do FT update number returned is negative if no room regionSparse starts as zero and is zero at end. | |
| int | updateColumn (CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2, bool noPermute=false) const |
| This version has same effect as above with FTUpdate==false so number returned is always >=0. | |
| int | updateTwoColumnsFT (CoinIndexedVector *regionSparse1, CoinIndexedVector *regionSparse2, CoinIndexedVector *regionSparse3, bool noPermuteRegion3=false) |
| Updates one column (FTRAN) from region2 Tries to do FT update number returned is negative if no room. | |
| int | updateColumnTranspose (CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const |
| Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - if regionSparse2 packed on input - will be packed on output. | |
| void | goSparse () |
| makes a row copy of L for speed and to allow very sparse problems | |
| int | sparseThreshold () const |
| get sparse threshold | |
| void | sparseThreshold (int value) |
| set sparse threshold | |
various uses of factorization (return code number elements) | |
which user may not want to know about (left over from my LP code) | |
| void | clearArrays () |
| Get rid of all memory. | |
various updates - none of which have been written! | |
| int | add (CoinBigIndex numberElements, int indicesRow[], int indicesColumn[], double elements[]) |
| Adds given elements to Basis and updates factorization, can increase size of basis. | |
| int | addColumn (CoinBigIndex numberElements, int indicesRow[], double elements[]) |
| Adds one Column to basis, can increase size of basis. | |
| int | addRow (CoinBigIndex numberElements, int indicesColumn[], double elements[]) |
| Adds one Row to basis, can increase size of basis. | |
| int | deleteColumn (int Row) |
| Deletes one Column from basis, returns rank. | |
| int | deleteRow (int Row) |
| Deletes one Row from basis, returns rank. | |
| int | replaceRow (int whichRow, int numberElements, const int indicesColumn[], const double elements[]) |
| Replaces one Row in basis, At present assumes just a singleton on row is in basis returns 0=OK, 1=Probably OK, 2=singular, 3 no space. | |
| void | emptyRows (int numberToEmpty, const int which[]) |
| Takes out all entries for given rows. | |
used by ClpFactorization | |
| void | checkSparse () |
| See if worth going sparse. | |
| bool | collectStatistics () const |
| For statistics. | |
| void | setCollectStatistics (bool onOff) const |
| For statistics. | |
| void | gutsOfDestructor (int type=1) |
| The real work of constructors etc 0 just scalars, 1 bit normal. | |
| void | gutsOfInitialize (int type) |
| 1 bit - tolerances etc, 2 more, 4 dummy arrays | |
| void | gutsOfCopy (const CoinFactorization &other) |
| See if worth going sparse. | |
| void | resetStatistics () |
| Reset all sparsity etc statistics. | |
Protected Attributes | |
data | |
| double | pivotTolerance_ |
| Pivot tolerance. | |
| double | zeroTolerance_ |
| Zero tolerance. | |
| double | slackValue_ |
| Whether slack value is +1 or -1. | |
| double | areaFactor_ |
| How much to multiply areas by. | |
| double | relaxCheck_ |
| Relax check on accuracy in replaceColumn. | |
| int | numberRows_ |
| Number of Rows in factorization. | |
| int | numberRowsExtra_ |
| Number of Rows after iterating. | |
| int | maximumRowsExtra_ |
| Maximum number of Rows after iterating. | |
| int | numberColumns_ |
| Number of Columns in factorization. | |
| int | numberColumnsExtra_ |
| Number of Columns after iterating. | |
| int | maximumColumnsExtra_ |
| Maximum number of Columns after iterating. | |
| int | numberGoodU_ |
| Number factorized in U (not row singletons). | |
| int | numberGoodL_ |
| Number factorized in L. | |
| int | maximumPivots_ |
| Maximum number of pivots before factorization. | |
| int | numberPivots_ |
| Number pivots since last factorization. | |
| CoinBigIndex | totalElements_ |
| Number of elements in U (to go) or while iterating total overall. | |
| CoinBigIndex | factorElements_ |
| Number of elements after factorization. | |
| CoinIntArrayWithLength | pivotColumn_ |
| Pivot order for each Column. | |
| CoinIntArrayWithLength | permute_ |
| Permutation vector for pivot row order. | |
| CoinIntArrayWithLength | permuteBack_ |
| DePermutation vector for pivot row order. | |
| CoinIntArrayWithLength | pivotColumnBack_ |
| Inverse Pivot order for each Column. | |
| int | status_ |
| Status of factorization. | |
| int | numberTrials_ |
| Number of trials before rejection. | |
| CoinBigIndexArrayWithLength | startRowU_ |
| Start of each Row as pointer. | |
| CoinIntArrayWithLength | numberInRow_ |
| Number in each Row. | |
| CoinIntArrayWithLength | numberInColumn_ |
| Number in each Column. | |
| CoinIntArrayWithLength | numberInColumnPlus_ |
| Number in each Column including pivoted. | |
| CoinIntArrayWithLength | firstCount_ |
| First Row/Column with count of k, can tell which by offset - Rows then Columns. | |
| CoinIntArrayWithLength | nextCount_ |
| Next Row/Column with count. | |
| CoinIntArrayWithLength | lastCount_ |
| Previous Row/Column with count. | |
| CoinIntArrayWithLength | nextColumn_ |
| Next Column in memory order. | |
| CoinIntArrayWithLength | lastColumn_ |
| Previous Column in memory order. | |
| CoinIntArrayWithLength | nextRow_ |
| Next Row in memory order. | |
| CoinIntArrayWithLength | lastRow_ |
| Previous Row in memory order. | |
| CoinIntArrayWithLength | saveColumn_ |
| Columns left to do in a single pivot. | |
| CoinIntArrayWithLength | markRow_ |
| Marks rows to be updated. | |
| int | messageLevel_ |
| Detail in messages. | |
| int | biggerDimension_ |
| Larger of row and column size. | |
| CoinIntArrayWithLength | indexColumnU_ |
| Base address for U (may change). | |
| CoinIntArrayWithLength | pivotRowL_ |
| Pivots for L. | |
| CoinDoubleArrayWithLength | pivotRegion_ |
| Inverses of pivot values. | |
| int | numberSlacks_ |
| Number of slacks at beginning of U. | |
| int | numberU_ |
| Number in U. | |
| CoinBigIndex | maximumU_ |
| Maximum space used in U. | |
| CoinBigIndex | lengthU_ |
| Length of U. | |
| CoinBigIndex | lengthAreaU_ |
| Length of area reserved for U. | |
| CoinDoubleArrayWithLength | elementU_ |
| Elements of U. | |
| CoinIntArrayWithLength | indexRowU_ |
| Row indices of U. | |
| CoinBigIndexArrayWithLength | startColumnU_ |
| Start of each column in U. | |
| CoinBigIndexArrayWithLength | convertRowToColumnU_ |
| Converts rows to columns in U. | |
| CoinBigIndex | numberL_ |
| Number in L. | |
| CoinBigIndex | baseL_ |
| Base of L. | |
| CoinBigIndex | lengthL_ |
| Length of L. | |
| CoinBigIndex | lengthAreaL_ |
| Length of area reserved for L. | |
| CoinDoubleArrayWithLength | elementL_ |
| Elements of L. | |
| CoinIntArrayWithLength | indexRowL_ |
| Row indices of L. | |
| CoinBigIndexArrayWithLength | startColumnL_ |
| Start of each column in L. | |
| bool | doForrestTomlin_ |
| true if Forrest Tomlin update, false if PFI | |
| int | numberR_ |
| Number in R. | |
| CoinBigIndex | lengthR_ |
| Length of R stuff. | |
| CoinBigIndex | lengthAreaR_ |
| length of area reserved for R | |
| double * | elementR_ |
| Elements of R. | |
| int * | indexRowR_ |
| Row indices for R. | |
| CoinBigIndexArrayWithLength | startColumnR_ |
| Start of columns for R. | |
| double * | denseArea_ |
| Dense area. | |
| int * | densePermute_ |
| Dense permutation. | |
| int | numberDense_ |
| Number of dense rows. | |
| int | denseThreshold_ |
| Dense threshold. | |
| CoinDoubleArrayWithLength | workArea_ |
| First work area. | |
| CoinUnsignedIntArrayWithLength | workArea2_ |
| Second work area. | |
| CoinBigIndex | numberCompressions_ |
| Number of compressions done. | |
| double | ftranCountInput_ |
| Below are all to collect. | |
| double | ftranCountAfterL_ |
| Pivot tolerance. | |
| double | ftranCountAfterR_ |
| Pivot tolerance. | |
| double | ftranCountAfterU_ |
| Pivot tolerance. | |
| double | btranCountInput_ |
| Pivot tolerance. | |
| double | btranCountAfterU_ |
| Pivot tolerance. | |
| double | btranCountAfterR_ |
| Pivot tolerance. | |
| double | btranCountAfterL_ |
| Pivot tolerance. | |
| int | numberFtranCounts_ |
| We can roll over factorizations. | |
| int | numberBtranCounts_ |
| Pivot tolerance. | |
| double | ftranAverageAfterL_ |
| While these are average ratios collected over last period. | |
| double | ftranAverageAfterR_ |
| Pivot tolerance. | |
| double | ftranAverageAfterU_ |
| Pivot tolerance. | |
| double | btranAverageAfterU_ |
| Pivot tolerance. | |
| double | btranAverageAfterR_ |
| Pivot tolerance. | |
| double | btranAverageAfterL_ |
| Pivot tolerance. | |
| bool | collectStatistics_ |
| For statistics. | |
| int | sparseThreshold_ |
| Below this use sparse technology - if 0 then no L row copy. | |
| int | sparseThreshold2_ |
| And one for "sparsish". | |
| CoinBigIndexArrayWithLength | startRowL_ |
| Start of each row in L. | |
| CoinIntArrayWithLength | indexColumnL_ |
| Index of column in row for L. | |
| CoinDoubleArrayWithLength | elementByRowL_ |
| Elements in L (row copy). | |
| CoinIntArrayWithLength | sparse_ |
| Sparse regions. | |
| int | biasLU_ |
| L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias. | |
| int | persistenceFlag_ |
| Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 but give a bit extra if bigger needed. | |
Friends | |
| void | CoinFactorizationUnitTest (const std::string &mpsDir) |
This class started with a parallel simplex code I was writing in the mid 90's. The need for parallelism led to many complications and I have simplified as much as I could to get back to this.
I was aiming at problems where I might get speed-up so I was looking at dense problems or ones with structure. This led to permuting input and output vectors and to increasing the number of rows each rank-one update. This is still in as a minor overhead.
I have also put in handling for hyper-sparsity. I have taken out all outer loop unrolling, dense matrix handling and most of the book-keeping for slacks. Also I always use FTRAN approach to updating even if factorization fairly dense. All these could improve performance.
I blame some of the coding peculiarities on the history of the code but mostly it is just because I can't do elegant code (or useful comments).
I am assuming that 32 bits is enough for number of rows or columns, but CoinBigIndex may be redefined to get 64 bits.
Definition at line 46 of file CoinFactorization.hpp.
| CoinFactorization::CoinFactorization | ( | ) |
Default constructor.
| CoinFactorization::CoinFactorization | ( | const CoinFactorization & | other | ) |
Copy constructor.
| CoinFactorization::~CoinFactorization | ( | ) |
Destructor.
| void CoinFactorization::almostDestructor | ( | ) |
Delete all stuff (leaves as after CoinFactorization()).
| void CoinFactorization::show_self | ( | ) | const |
Debug show object (shows one representation).
| int CoinFactorization::saveFactorization | ( | const char * | file | ) | const |
Debug - save on file - 0 if no error.
| int CoinFactorization::restoreFactorization | ( | const char * | file, | |
| bool | factor = false | |||
| ) |
Debug - restore from file - 0 if no error on file.
If factor true then factorizes as if called from ClpFactorization
| void CoinFactorization::sort | ( | ) | const |
Debug - sort so can compare.
| CoinFactorization& CoinFactorization::operator= | ( | const CoinFactorization & | other | ) |
= copy
| int CoinFactorization::factorize | ( | const CoinPackedMatrix & | matrix, | |
| int | rowIsBasic[], | |||
| int | columnIsBasic[], | |||
| double | areaFactor = 0.0 | |||
| ) |
When part of LP - given by basic variables.
Actually does factorization. Arrays passed in have non negative value to say basic. If status is okay, basic variables have pivot row - this is only needed If status is singular, then basic variables have pivot row and ones thrown out have -1 returns 0 -okay, -1 singular, -2 too many in basis, -99 memory
| int CoinFactorization::factorize | ( | int | numberRows, | |
| int | numberColumns, | |||
| CoinBigIndex | numberElements, | |||
| CoinBigIndex | maximumL, | |||
| CoinBigIndex | maximumU, | |||
| const int | indicesRow[], | |||
| const int | indicesColumn[], | |||
| const double | elements[], | |||
| int | permutation[], | |||
| double | areaFactor = 0.0 | |||
| ) |
When given as triplets.
Actually does factorization. maximumL is guessed maximum size of L part of final factorization, maximumU of U part. These are multiplied by areaFactor which can be computed by user or internally. Arrays are copied in. I could add flag to delete arrays to save a bit of memory. If status okay, permutation has pivot rows - this is only needed If status is singular, then basic variables have pivot row and ones thrown out have -1 returns 0 -okay, -1 singular, -99 memory
| int CoinFactorization::factorizePart1 | ( | int | numberRows, | |
| int | numberColumns, | |||
| CoinBigIndex | estimateNumberElements, | |||
| int * | indicesRow[], | |||
| int * | indicesColumn[], | |||
| double * | elements[], | |||
| double | areaFactor = 0.0 | |||
| ) |
Two part version for maximum flexibility This part creates arrays for user to fill.
estimateNumberElements is safe estimate of number returns 0 -okay, -99 memory
| int CoinFactorization::factorizePart2 | ( | int | permutation[], | |
| int | exactNumberElements | |||
| ) |
This is part two of factorization Arrays belong to factorization and were returned by part 1 If status okay, permutation has pivot rows - this is only needed If status is singular, then basic variables have pivot row and ones thrown out have -1 returns 0 -okay, -1 singular, -99 memory.