Go to the documentation of this file.
12 #ifndef CoinFactorization_H
13 #define CoinFactorization_H
90 int rowIsBasic[],
int columnIsBasic[] ,
107 const int indicesRow[],
108 const int indicesColumn[],
const double elements[] ,
119 int * indicesColumn[],
136 inline int status ( )
const {
275 #ifndef COIN_FAST_CODE
379 bool checkBeforeModifying=
false,
380 double acceptablePivot=1.0e-8);
387 int internalPivotRow);
388 #ifdef ABC_USE_COIN_FACTORIZATION
392 int already=0)
const;
410 int checkReplacePart2 (
int pivotRow,
414 double acceptablePivot = 1.0e-8);
455 void updateColumnTransposeCpu (
CoinIndexedVector & regionSparse,
int whichCpu)
const;
463 inline bool wantsTableauColumn()
const
466 inline double minimumPivotTolerance ( )
const {
469 inline void minimumPivotTolerance (
double value )
472 inline void setParallelMode(
int value)
473 { parallelMode_=value;}
475 inline void setSolveMode(
int value)
476 { parallelMode_ &= 3;parallelMode_ |= (value<<2);}
478 inline int solveMode()
const
479 {
return parallelMode_ >> 2;}
502 bool noPermute=
false)
const;
511 bool noPermuteRegion3=
false) ;
543 int indicesColumn[],
double elements[] );
548 int indicesRow[],
double elements[] );
553 int indicesColumn[],
double elements[] );
564 const int indicesColumn[],
const double elements[] );
572 #if 0 //def CLP_FACTORIZATION_INSTRUMENT
607 int possibleDuplicates = -1 );
669 inline void addLink (
int index,
int count ) {
673 int next = firstCount[count];
674 lastCount[index] = -2 - count;
677 firstCount[count] = index;
678 nextCount[index] = -1;
680 firstCount[count] = index;
681 nextCount[index] = next;
682 lastCount[next] = index;
689 int next = nextCount[index];
690 int last = lastCount[index];
692 nextCount[last] = next;
694 int count = -last - 2;
696 firstCount[count] = next;
699 lastCount[next] = last;
701 nextCount[index] = -2;
702 lastCount[index] = -2;
730 int * indexIn)
const;
733 int * indexIn)
const;
739 int & numberNonZero1,
742 int & numberNonZero2,
756 int smallestIndex)
const;
760 int smallestIndex)
const;
764 int smallestIndex)
const;
771 int smallestIndex)
const;
796 int pivotRow,
double alpha);
803 #define COINFACTORIZATION_BITS_PER_INT 64
804 #define COINFACTORIZATION_SHIFT_PER_INT 6
805 #define COINFACTORIZATION_MASK_PER_INT 0x3f
807 #define COINFACTORIZATION_BITS_PER_INT 32
808 #define COINFACTORIZATION_SHIFT_PER_INT 5
809 #define COINFACTORIZATION_MASK_PER_INT 0x1f
811 template <
class T>
inline bool
817 unsigned int workArea2[],
839 CoinBigIndex endColumn = startColumn + numberInPivotColumn + 1;
844 if ( pivotColumnPosition < 0 ) {
845 for ( pivotColumnPosition = startRow; pivotColumnPosition < endRow; pivotColumnPosition++ ) {
846 int iColumn = indexColumnU[pivotColumnPosition];
848 saveColumn[put++] = iColumn;
854 for (
CoinBigIndex i = startRow ; i < pivotColumnPosition ; i++ ) {
855 saveColumn[put++] = indexColumnU[i];
858 assert (pivotColumnPosition<endRow);
859 assert (indexColumnU[pivotColumnPosition]==
pivotColumn);
860 pivotColumnPosition++;
861 for ( ; pivotColumnPosition < endRow; pivotColumnPosition++ ) {
862 saveColumn[put++] = indexColumnU[pivotColumnPosition];
865 int next = nextRow[pivotRow];
868 nextRow[last] = next;
879 printf(
"more memory needed in middle of invert\n");
890 if ( pivotRowPosition < 0 ) {
891 for ( pivotRowPosition = startColumn; pivotRowPosition < endColumn; pivotRowPosition++ ) {
893 if ( iRow != pivotRow ) {
895 elementL[l] =
elementU[pivotRowPosition];
896 markRow[iRow] =
static_cast<T
>(l - lSave);
907 if ( where >= end ) {
911 indexColumnU[where] = indexColumnU[end - 1];
920 for ( i = startColumn; i < pivotRowPosition; i++ ) {
923 markRow[iRow] =
static_cast<T
>(l - lSave);
936 if ( where >= end ) {
940 indexColumnU[where] = indexColumnU[end - 1];
945 assert (pivotRowPosition<endColumn);
946 assert (
indexRowU[pivotRowPosition]==pivotRow);
952 for ( ; pivotRowPosition < endColumn; pivotRowPosition++ ) {
955 markRow[iRow] =
static_cast<T
>(l - lSave);
957 elementL[l] =
elementU[pivotRowPosition];
968 if ( where >= end ) {
972 indexColumnU[where] = indexColumnU[end - 1];
976 markRow[pivotRow] =
static_cast<T
>(largeInteger);
986 for ( j = 0; j < numberInPivotColumn; j++ ) {
987 multipliersL[j] *= pivotMultiplier;
991 for ( iErase = 0; iErase < increment2 * numberInPivotRow;
993 workArea2[iErase] = 0;
995 CoinBigIndex added = numberInPivotRow * numberInPivotColumn;
996 unsigned int *temp2 = workArea2;
1001 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1002 int iColumn = saveColumn[jColumn];
1014 int mark = markRow[iRow];
1016 if ( mark == largeInteger+1 ) {
1017 largest = fabs ( value );
1018 positionLargest = put;
1020 checkLargest =
false;
1024 checkLargest =
true;
1025 if ( mark != largeInteger ) {
1031 temp2[word] = temp2[word] | ( 1 << bit );
1034 thisPivotValue = value;
1038 for ( i = startColumn + 1; i < endColumn; i++ ) {
1041 int mark = markRow[iRow];
1043 if ( mark == largeInteger+1 ) {
1047 if ( checkLargest ) {
1048 double absValue = fabs ( value );
1050 if ( absValue > largest ) {
1052 positionLargest = put;
1056 }
else if ( mark != largeInteger ) {
1062 temp2[word] = temp2[word] | ( 1 << bit );
1065 thisPivotValue = value;
1071 if ( positionLargest == startColumn ) {
1072 positionLargest = put;
1075 elementU[startColumn] = thisPivotValue;
1081 numberInColumnPlus[iColumn]++;
1084 int next = nextColumn[iColumn];
1087 space =
startColumnU[next] - put - numberInColumnPlus[next];
1089 if ( numberInPivotColumn > space ) {
1095 if (positionLargest >= 0)
1096 positionLargest = positionLargest +
startColumnU[iColumn] - startColumn;
1103 for ( j = 0; j < numberInPivotColumn; j++ ) {
1104 value = work[j] - thisPivotValue * multipliersL[j];
1105 double absValue = fabs ( value );
1107 if ( absValue > tolerance ) {
1112 if ( absValue > largest ) {
1114 positionLargest = put;
1123 if ( temp2[word] & ( 1 << bit ) ) {
1130 while ( indexColumnU[where] != iColumn ) {
1134 if ( where >= end ) {
1138 indexColumnU[where] = indexColumnU[end - 1];
1145 temp2[word] = temp2[word] | ( 1 << bit );
1151 if ( positionLargest >= 0 ) {
1165 temp2 += increment2;
1168 unsigned int *putBase = workArea2;
1173 while ( bigLoops ) {
1177 unsigned int *putThis = putBase;
1178 int iRow = indexL[i];
1184 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1185 unsigned int test = *putThis;
1187 putThis += increment2;
1188 test = 1 - ( ( test >> bit ) & 1 );
1191 int next = nextRow[iRow];
1194 space = startRowU[next] - startRowU[iRow];
1196 if ( space < number ) {
1203 next = nextRow[iRow];
1206 int saveIndex = indexColumnU[startRowU[next]];
1209 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1210 unsigned int test = *putThis;
1212 putThis += increment2;
1213 test = 1 - ( ( test >> bit ) & 1 );
1214 indexColumnU[end] = saveColumn[jColumn];
1218 indexColumnU[startRowU[next]] = saveIndex;
1219 markRow[iRow] =
static_cast<T
>(largeInteger+1);
1220 number = end - startRowU[iRow];
1229 for ( bit = 0; i < numberInPivotColumn; i++, bit++ ) {
1230 unsigned int *putThis = putBase;
1231 int iRow = indexL[i];
1237 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1238 unsigned int test = *putThis;
1240 putThis += increment2;
1241 test = 1 - ( ( test >> bit ) & 1 );
1244 int next = nextRow[iRow];
1247 space = startRowU[next] - startRowU[iRow];
1249 if ( space < number ) {
1256 next = nextRow[iRow];
1261 saveIndex = indexColumnU[startRowU[next]];
1264 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1265 unsigned int test = *putThis;
1267 putThis += increment2;
1268 test = 1 - ( ( test >> bit ) & 1 );
1270 indexColumnU[end] = saveColumn[jColumn];
1273 indexColumnU[startRowU[next]] = saveIndex;
1274 markRow[iRow] =
static_cast<T
>(largeInteger+1);
1275 number = end - startRowU[iRow];
1280 markRow[pivotRow] =
static_cast<T
>(largeInteger+1);
1299 #ifndef COIN_FAST_CODE
1304 #define slackValue_ -1.0
1534 #define collectStatistics_ 1
1564 #ifdef ABC_USE_COIN_FACTORIZATION
1571 #ifdef COIN_HAS_LAPACK
1572 #ifndef COIN_FACTORIZATION_DENSE_CODE
1573 #define COIN_FACTORIZATION_DENSE_CODE 1
1576 #ifdef COIN_FACTORIZATION_DENSE_CODE
1581 typedef const int cipfint;
1586 #ifdef UGLY_COIN_FACTOR_CODING
1587 #define FAC_UNSET (FAC_SET+1)
1591 CoinBigIndex startColumnThis = startColumn[iPivotColumn];
1592 CoinBigIndex endColumn = startColumnThis + numberDoColumn + 1;
1596 if ( pivotColumnPosition < 0 ) {
1597 for ( pivotColumnPosition = startRowThis; pivotColumnPosition < endRow; pivotColumnPosition++ ) {
1598 int iColumn = indexColumn[pivotColumnPosition];
1599 if ( iColumn != iPivotColumn ) {
1600 saveColumn[put++] = iColumn;
1606 for (
CoinBigIndex i = startRowThis ; i < pivotColumnPosition ; i++ ) {
1607 saveColumn[put++] = indexColumn[i];
1610 assert (pivotColumnPosition<endRow);
1611 assert (indexColumn[pivotColumnPosition]==iPivotColumn);
1612 pivotColumnPosition++;
1613 for ( ; pivotColumnPosition < endRow; pivotColumnPosition++ ) {
1614 saveColumn[put++] = indexColumn[pivotColumnPosition];
1617 int next = nextRow[iPivotRow];
1618 int last = lastRow[iPivotRow];
1620 nextRow[last] = next;
1621 lastRow[next] = last;
1622 nextRow[iPivotRow] = numberGoodU_;
1623 lastRow[iPivotRow] = -2;
1624 numberInRow[iPivotRow] = 0;
1629 if ( l + numberDoColumn > lengthAreaL_ ) {
1631 if ((messageLevel_&4)!=0)
1632 printf(
"more memory needed in middle of invert\n");
1639 startColumnL[numberGoodL_] = l;
1641 startColumnL[numberGoodL_] = l + numberDoColumn;
1642 lengthL_ += numberDoColumn;
1643 if ( pivotRowPosition < 0 ) {
1644 for ( pivotRowPosition = startColumnThis; pivotRowPosition < endColumn; pivotRowPosition++ ) {
1645 int iRow = indexRow[pivotRowPosition];
1646 if ( iRow != iPivotRow ) {
1647 indexRowL[l] = iRow;
1648 elementL[l] = element[pivotRowPosition];
1649 markRow[iRow] = l - lSave;
1656 while ( indexColumn[where] != iPivotColumn ) {
1660 if ( where >= end ) {
1664 indexColumn[where] = indexColumn[end - 1];
1665 numberInRow[iRow]--;
1673 for ( i = startColumnThis; i < pivotRowPosition; i++ ) {
1674 int iRow = indexRow[i];
1676 markRow[iRow] = l - lSave;
1677 indexRowL[l] = iRow;
1678 elementL[l] = element[i];
1685 while ( indexColumn[where] != iPivotColumn ) {
1689 if ( where >= end ) {
1693 indexColumn[where] = indexColumn[end - 1];
1694 numberInRow[iRow]--;
1695 assert (numberInRow[iRow]>=0);
1698 assert (pivotRowPosition<endColumn);
1699 assert (indexRow[pivotRowPosition]==iPivotRow);
1703 pivotRegion_.array()[numberGoodU_] = pivotMultiplier;
1705 for ( ; pivotRowPosition < endColumn; pivotRowPosition++ ) {
1706 int iRow = indexRow[pivotRowPosition];
1708 markRow[iRow] = l - lSave;
1709 indexRowL[l] = iRow;
1710 elementL[l] = element[pivotRowPosition];
1717 while ( indexColumn[where] != iPivotColumn ) {
1721 if ( where >= end ) {
1725 indexColumn[where] = indexColumn[end - 1];
1726 numberInRow[iRow]--;
1727 assert (numberInRow[iRow]>=0);
1729 markRow[iPivotRow] = FAC_SET;
1731 numberInColumn[iPivotColumn] = 0;
1733 int *indexL = &indexRowL[lSave];
1739 for ( j = 0; j < numberDoColumn; j++ ) {
1740 multipliersL[j] *= pivotMultiplier;
1744 for ( iErase = 0; iErase < increment2 * numberDoRow;
1746 workArea2[iErase] = 0;
1749 unsigned int *temp2 = workArea2;
1750 int * nextColumn = nextColumn_.array();
1754 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
1755 int iColumn = saveColumn[jColumn];
1757 CoinBigIndex endColumn = startColumnThis + numberInColumn[iColumn];
1758 int iRow = indexRow[startColumnThis];
1767 int mark = markRow[iRow];
1769 if ( mark == FAC_UNSET ) {
1770 largest = fabs ( value );
1771 positionLargest = put;
1773 checkLargest =
false;
1777 checkLargest =
true;
1778 if ( mark != FAC_SET ) {
1780 workArea[mark] = value;
1784 temp2[word] = temp2[word] | ( 1 << bit );
1787 thisPivotValue = value;
1791 for ( i = startColumnThis + 1; i < endColumn; i++ ) {
1794 int mark = markRow[iRow];
1796 if ( mark == FAC_UNSET ) {
1798 indexRow[put] = iRow;
1799 element[put] = value;
1800 if ( checkLargest ) {
1801 double absValue = fabs ( value );
1803 if ( absValue > largest ) {
1805 positionLargest = put;
1809 }
else if ( mark != FAC_SET ) {
1811 workArea[mark] = value;
1815 temp2[word] = temp2[word] | ( 1 << bit );
1818 thisPivotValue = value;
1822 element[put] = element[startColumnThis];
1823 indexRow[put] = indexRow[startColumnThis];
1824 if ( positionLargest == startColumnThis ) {
1825 positionLargest = put;
1828 element[startColumnThis] = thisPivotValue;
1829 indexRow[startColumnThis] = iPivotRow;
1832 numberInColumn[iColumn] = put - startColumnThis;
1833 int * numberInColumnPlus = numberInColumnPlus_.array();
1834 numberInColumnPlus[iColumn]++;
1835 startColumn[iColumn]++;
1837 int next = nextColumn[iColumn];
1840 space = startColumn[next] - put - numberInColumnPlus[next];
1842 if ( numberDoColumn > space ) {
1844 if ( !getColumnSpace ( iColumn, numberDoColumn ) ) {
1848 positionLargest = positionLargest + startColumn[iColumn] - startColumnThis;
1849 startColumnThis = startColumn[iColumn];
1850 put = startColumnThis + numberInColumn[iColumn];
1852 double tolerance = zeroTolerance_;
1854 int *nextCount = nextCount_.array();
1855 for ( j = 0; j < numberDoColumn; j++ ) {
1856 value = workArea[j] - thisPivotValue * multipliersL[j];
1857 double absValue = fabs ( value );
1859 if ( absValue > tolerance ) {
1861 element[put] = value;
1862 indexRow[put] = indexL[j];
1863 if ( absValue > largest ) {
1865 positionLargest = put;
1874 if ( temp2[word] & ( 1 << bit ) ) {
1881 while ( indexColumn[where] != iColumn ) {
1885 if ( where >= end ) {
1889 indexColumn[where] = indexColumn[end - 1];
1890 numberInRow[iRow]--;
1896 temp2[word] = temp2[word] | ( 1 << bit );
1900 numberInColumn[iColumn] = put - startColumnThis;
1902 if ( positionLargest >= 0 ) {
1903 value = element[positionLargest];
1904 iRow = indexRow[positionLargest];
1905 element[positionLargest] = element[startColumnThis];
1906 indexRow[positionLargest] = indexRow[startColumnThis];
1907 element[startColumnThis] = value;
1908 indexRow[startColumnThis] = iRow;
1911 if ( nextCount[iColumn + numberRows_] != -2 ) {
1913 deleteLink ( iColumn + numberRows_ );
1914 addLink ( iColumn + numberRows_, numberInColumn[iColumn] );
1916 temp2 += increment2;
1919 unsigned int *putBase = workArea2;
1924 while ( bigLoops ) {
1928 unsigned int *putThis = putBase;
1929 int iRow = indexL[i];
1935 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
1936 unsigned int test = *putThis;
1938 putThis += increment2;
1939 test = 1 - ( ( test >> bit ) & 1 );
1942 int next = nextRow[iRow];
1945 space = startRow[next] - startRow[iRow];
1946 number += numberInRow[iRow];
1947 if ( space < number ) {
1948 if ( !getRowSpace ( iRow, number ) ) {
1954 next = nextRow[iRow];
1955 number = numberInRow[iRow];
1957 int saveIndex = indexColumn[startRow[next]];
1960 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
1961 unsigned int test = *putThis;
1963 putThis += increment2;
1964 test = 1 - ( ( test >> bit ) & 1 );
1965 indexColumn[end] = saveColumn[jColumn];
1969 indexColumn[startRow[next]] = saveIndex;
1970 markRow[iRow] = FAC_UNSET;
1971 number = end - startRow[iRow];
1972 numberInRow[iRow] = number;
1973 deleteLink ( iRow );
1974 addLink ( iRow, number );
1980 for ( bit = 0; i < numberDoColumn; i++, bit++ ) {
1981 unsigned int *putThis = putBase;
1982 int iRow = indexL[i];
1988 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
1989 unsigned int test = *putThis;
1991 putThis += increment2;
1992 test = 1 - ( ( test >> bit ) & 1 );
1995 int next = nextRow[iRow];
1998 space = startRow[next] - startRow[iRow];
1999 number += numberInRow[iRow];
2000 if ( space < number ) {
2001 if ( !getRowSpace ( iRow, number ) ) {
2007 next = nextRow[iRow];
2008 number = numberInRow[iRow];
2012 saveIndex = indexColumn[startRow[next]];
2015 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
2016 unsigned int test = *putThis;
2018 putThis += increment2;
2019 test = 1 - ( ( test >> bit ) & 1 );
2021 indexColumn[end] = saveColumn[jColumn];
2024 indexColumn[startRow[next]] = saveIndex;
2025 markRow[iRow] = FAC_UNSET;
2026 number = end - startRow[iRow];
2027 numberInRow[iRow] = number;
2028 deleteLink ( iRow );
2029 addLink ( iRow, number );
2031 markRow[iPivotRow] = FAC_UNSET;
2033 deleteLink ( iPivotRow );
2034 deleteLink ( iPivotColumn + numberRows_ );
2035 totalElements_ += added;
int deleteRow(int Row)
Deletes one Row from basis, returns rank.
bool pivotRowSingleton(int pivotRow, int pivotColumn)
Does one pivot on Row Singleton in factorization.
void checkConsistency()
Checks that row and column copies look OK.
void relaxAccuracyCheck(double value)
Allows change of pivot accuracy check 1.0 == none >1.0 relaxed.
void gutsOfInitialize(int type)
1 bit - tolerances etc, 2 more, 4 dummy arrays
CoinIntArrayWithLength numberInRow_
Number in each Row.
int numberColumnsExtra_
Number of Columns after iterating.
void cleanup()
Cleans up at end of factorization.
void getAreas(int numberRows, int numberColumns, CoinBigIndex maximumL, CoinBigIndex maximumU)
Gets space for a factorization, called by constructors.
int maximumPivots_
Maximum number of pivots before factorization.
int numberGoodColumns() const
Number of good columns in factorization.
double * denseArea_
Dense area.
double pivotTolerance() const
Pivot tolerance.
void updateColumnTransposeRDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when dense.
void updateColumnTransposeLDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by column.
double adjustedAreaFactor() const
Returns areaFactor but adjusted for dense.
CoinBigIndex lengthAreaU() const
Returns length of U area.
void setDenseThreshold(int value)
Sets dense threshold.
double relaxCheck_
Relax check on accuracy in replaceColumn.
#define COINFACTORIZATION_BITS_PER_INT
double conditionNumber() const
Condition number - product of pivots after factorization.
void updateColumnTransposeUSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANU) when sparse, assumes index is sorted i.e.
int updateColumnFT(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2)
Updates one column (FTRAN) from regionSparse2 Tries to do FT update number returned is negative if no...
CoinFactorizationDoubleArrayWithLength elementByRowL_
Elements in L (row copy)
CoinIntArrayWithLength lastCount_
Previous Row/Column with count.
bool getRowSpaceIterate(int iRow, int extraNeeded)
Gets space for one Row with given length while iterating, may have to do compression (returns True if...
int numberRows_
Number of Rows in factorization.
CoinBigIndex lengthR_
Length of R stuff.
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 factorSparseSmall()
Does sparse phase of factorization (for smaller problems) return code is <0 error,...
int numberGoodL_
Number factorized in L.
double CoinFactorizationDouble
double * denseAreaAddress_
Dense area - actually used (for alignment etc)
void setCollectStatistics(bool onOff) const
For statistics.
int factorize(const CoinPackedMatrix &matrix, int rowIsBasic[], int columnIsBasic[], double areaFactor=0.0)
When part of LP - given by basic variables.
bool spaceForForrestTomlin() const
True if FT update and space.
void permuteBack(CoinIndexedVector *regionSparse, CoinIndexedVector *outVector) const
Permutes back at end of updateColumn.
CoinIntArrayWithLength numberInColumn_
Number in each Column.
int restoreFactorization(const char *file, bool factor=false)
Debug - restore from file - 0 if no error on file.
CoinBigIndex lengthL_
Length of L.
int maximumPivots() const
Maximum number of pivots between factorizations.
int sparseThreshold() const
get sparse threshold
CoinBigIndex factorElements_
Number of elements after factorization.
CoinBigIndex lengthAreaL() const
Returns length of L area.
int factor()
Does most of factorization.
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.
void setPersistenceFlag(int value)
CoinBigIndexArrayWithLength startRowU_
Start of each Row as pointer.
double zeroTolerance() const
Zero tolerance.
CoinFactorizationDouble * elementByRowL() const
Elements in L (row copy)
void gutsOfCopy(const CoinFactorization &other)
#define collectStatistics_
For statistics.
CoinFactorizationDoubleArrayWithLength pivotRegion_
Inverses of pivot values.
int * densePermute_
Dense permutation.
int numberPivots_
Number pivots since last factorization.
int numberRowsExtra() const
Number of Rows after iterating.
int maximumRowsExtra_
Maximum number of Rows after iterating.
void sparseThreshold(int value)
set sparse threshold
CoinFactorizationDouble * array() const
Get Array.
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 sparseThreshold_
Below this use sparse technology - if 0 then no L row copy.
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 numberRows() const
Number of Rows after factorization.
CoinIntArrayWithLength firstCount_
First Row/Column with count of k, can tell which by offset - Rows then Columns.
void updateColumnUSparse(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparse.
void almostDestructor()
Delete all stuff (leaves as after CoinFactorization())
bool doForrestTomlin_
true if Forrest Tomlin update, false if PFI
void setPivots(int value)
Sets number of pivots since factorization.
CoinBigIndexArrayWithLength startColumnL_
Start of each column in L.
CoinIntArrayWithLength lastRow_
Previous Row in memory order.
CoinFactorization(const CoinFactorization &other)
Copy constructor.
int updateColumnUDensish(double *COIN_RESTRICT region, int *COIN_RESTRICT regionIndex) const
Updates part of column (FTRANU)
void setForrestTomlin(bool value)
void maximumPivots(int value)
int denseThreshold_
Dense threshold.
CoinBigIndex * startColumnL() const
Start of each column in L.
void setStatus(int value)
Sets status.
void updateColumnL(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL)
void deleteLink(int index)
Deletes a link in chain of equal counts.
CoinIntArrayWithLength lastColumn_
Previous Column in memory order.
CoinFactorizationDoubleArrayWithLength elementL_
Elements of L.
CoinBigIndex lengthAreaR_
length of area reserved for R
void updateColumnU(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANU)
double areaFactor() const
Whether larger areas needed.
int addRow(CoinBigIndex numberElements, int indicesColumn[], double elements[])
Adds one Row to basis, can increase size of basis.
int * array() const
Get Array.
double ftranAverageAfterU_
double btranAverageAfterU_
void replaceColumnU(CoinIndexedVector *regionSparse, CoinBigIndex *deleted, int internalPivotRow)
Combines BtranU and delete elements If deleted is NULL then delete elements otherwise store where ele...
int numberForrestTomlin() const
Length of FT vector.
CoinBigIndex lengthAreaU_
Length of area reserved for U.
int maximumColumnsExtra()
Maximum number of Columns after iterating.
int * pivotColumnBack() const
Returns address of pivotColumnBack region (also used for permuting) Now uses firstCount to save memor...
int * numberInColumn() const
Number of entries in each column.
int checkPivot(double saveFromU, double oldPivot) const
Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular.
friend void CoinFactorizationUnitTest(const std::string &mpsDir)
void show_self() const
Debug show object (shows one representation)
int biasLU_
L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias.
CoinBigIndex baseL() const
Base of L.
void updateColumnTransposeUByColumn(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) by column assumes index is sorted i.e.
void updateColumnTransposeL(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL)
void updateColumnTransposeUSparsish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when sparsish, assumes index is sorted i....
CoinBigIndex getColumnSpaceIterate(int iColumn, double value, int iRow)
getColumnSpaceIterate.
void updateColumnLSparsish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparsish.
CoinBigIndex * array() const
Get Array.
double zeroTolerance_
Zero tolerance.
CoinBigIndex numberElementsU() const
Returns number in U area.
void updateColumnTransposeRSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when sparse.
CoinFactorizationDoubleArrayWithLength elementU_
Elements of U.
CoinIntArrayWithLength pivotRowL_
Pivots for L.
~CoinFactorization()
Destructor.
This deals with Factorization and Updates.
int numberTrials_
0 - no increasing rows - no permutations, 1 - no increasing rows but permutations 2 - increasing rows
CoinFactorizationDoubleArrayWithLength workArea_
First work area.
void resetStatistics()
Reset all sparsity etc statistics.
int factorSparseLarge()
Does sparse phase of factorization (for larger problems) return code is <0 error, 0= finished.
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.
CoinFactorization()
Default constructor.
int numberGoodU_
Number factorized in U (not row singletons)
bool collectStatistics() const
For statistics.
int factorizePart1(int numberRows, int numberColumns, CoinBigIndex estimateNumberElements, int *indicesRow[], int *indicesColumn[], CoinFactorizationDouble *elements[], double areaFactor=0.0)
Two part version for maximum flexibility This part creates arrays for user to fill.
double ftranAverageAfterR_
bool pivot(int pivotRow, int pivotColumn, CoinBigIndex pivotRowPosition, CoinBigIndex pivotColumnPosition, CoinFactorizationDouble work[], unsigned int workArea2[], int increment2, T markRow[], int largeInteger)
int * indexRowL() const
Row indices of L.
int factorDense()
Does dense phase of factorization return code is <0 error, 0= finished.
#define COINFACTORIZATION_MASK_PER_INT
double btranAverageAfterL_
CoinBigIndexArrayWithLength convertRowToColumnU_
Converts rows to columns in U.
void updateColumnTransposeR(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR)
int * permuteBack() const
Returns address of permuteBack region.
void updateColumnLDensish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when densish.
CoinIntArrayWithLength permuteBack_
DePermutation vector for pivot row order.
int saveFactorization(const char *file) const
Debug - save on file - 0 if no error.
CoinFactorization & operator=(const CoinFactorization &other)
= copy
CoinIntArrayWithLength indexColumnU_
Base address for U (may change)
int updateColumnTranspose(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const
Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - i...
CoinBigIndex lengthAreaL_
Length of area reserved for L.
CoinIntArrayWithLength pivotColumnBack_
Inverse Pivot order for each Column.
CoinBigIndex * startRowL() const
Start of each row in L.
CoinIntArrayWithLength indexRowL_
Row indices of L.
CoinBigIndex lengthU_
Base of U is always 0.
double getAccuracyCheck() const
double maximumCoefficient() const
Returns maximum absolute value in factorization.
double slackValue_
Whether slack value is +1 or -1.
double pivotTolerance_
Pivot tolerance.
CoinIntArrayWithLength indexColumnL_
Index of column in row for L.
CoinBigIndex maximumU_
Maximum space used in U.
CoinBigIndex * startColumnU() const
Start of each column in U.
bool getColumnSpace(int iColumn, int extraNeeded)
Gets space for one Column with given length, may have to do compression (returns True if successful),...
int persistenceFlag_
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
CoinIntArrayWithLength permute_
Permutation vector for pivot row order.
int replaceColumn(CoinIndexedVector *regionSparse, int pivotRow, double pivotCheck, bool checkBeforeModifying=false, double acceptablePivot=1.0e-8)
Replaces one Column to basis, returns 0=OK, 1=Probably OK, 2=singular, 3=no room If checkBeforeModify...
int numberRowsExtra_
Number of Rows after iterating.
int numberDense() const
Returns number of dense rows.
int factorSparse()
Does sparse phase of factorization return code is <0 error, 0= finished.
int * lastRow() const
Returns address of lastRow region.
CoinBigIndex totalElements_
Number of elements in U (to go) or while iterating total overall.
int * permute() const
Returns address of permute region.
void updateColumnTransposeUDensish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when densish, assumes index is sorted i....
CoinBigIndex numberCompressions() const
Number of compressions done.
void updateColumnPFI(CoinIndexedVector *regionSparse) const
Updates part of column PFI (FTRAN) (after rest)
int * indexColumnL() const
Index of column in row for L.
int deleteColumn(int Row)
Deletes one Column from basis, returns rank.
int numberDense_
Number of dense rows.
int messageLevel_
Detail in messages.
void updateColumnTransposeLSparsish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparsish by row.
void setBiasLU(int value)
CoinIntArrayWithLength nextCount_
Next Row/Column with count.
void addLink(int index, int count)
Adds a link in chain of equal counts.
int status() const
Returns status.
int sparseThreshold2_
And one for "sparsish".
int maximumRowsExtra() const
Maximum of Rows after iterating.
CoinBigIndexArrayWithLength startRowL_
Start of each row in L.
Sparse Matrix Base Class.
void preProcess(int state, int possibleDuplicates=-1)
PreProcesses raw triplet data.
int * indexRowU() const
Row indices of U.
void updateColumnR(CoinIndexedVector *region) const
Updates part of column (FTRANR) without FT update.
void gutsOfDestructor(int type=1)
The real work of constructors etc 0 just scalars, 1 bit normal.
CoinIntArrayWithLength indexRowU_
Row indices of U.
CoinFactorizationDouble * version.
int pivots() const
Returns number of pivots since factorization.
CoinBigIndex numberElementsL() const
Returns number in L area.
bool reorderU()
Reorders U so contiguous and in order (if there is space) Returns true if it could.
int numberColumns() const
Total number of columns in factorization.
void emptyRows(int numberToEmpty, const int which[])
Takes out all entries for given rows.
bool pivotColumnSingleton(int pivotRow, int pivotColumn)
Does one pivot on Column Singleton in factorization.
CoinFactorizationDouble * elementR_
Elements of R.
CoinBigIndex numberElementsR() const
Returns number in R area.
int maximumColumnsExtra_
Maximum number of Columns after iterating.
void setNumberElementsU(CoinBigIndex value)
Setss number in U area.
CoinBigIndex numberL() const
Number in L.
void updateColumnRFT(CoinIndexedVector *region, int *indexIn)
Updates part of column (FTRANR) with FT update.
void messageLevel(int value)
CoinBigIndex numberL_
Number in L.
CoinFactorizationDouble * elementU() const
Elements of U.
bool getRowSpace(int iRow, int extraNeeded)
Gets space for one Row with given length, may have to do compression (returns True if successful),...
void sort() const
Debug - sort so can compare.
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,...
int messageLevel() const
Level of detail of messages.
void areaFactor(double value)
int * pivotColumn() const
Returns address of pivotColumn region (also used for permuting)
CoinIntArrayWithLength sparse_
Sparse regions.
bool getColumnSpaceIterateR(int iColumn, double value, int iRow)
getColumnSpaceIterateR.
int numberElements() const
Total number of elements in factorization.
CoinFactorizationDouble * pivotRegion() const
Returns address of pivot region.
double ftranAverageAfterL_
While these are average ratios collected over last period.
double ftranCountInput_
Below are all to collect.
void updateColumnUSparsish(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparsish.
void updateColumnTransposeU(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU), assumes index is sorted i.e.
bool pivotOneOtherRow(int pivotRow, int pivotColumn)
Pivots when just one other row so faster?
int biggerDimension_
Larger of row and column size.
CoinIntArrayWithLength pivotColumn_
Pivot order for each Column.
int factorizePart2(int permutation[], int exactNumberElements)
This is part two of factorization Arrays belong to factorization and were returned by part 1 If statu...
CoinIntArrayWithLength nextColumn_
Next Column in memory order.
int addColumn(CoinBigIndex numberElements, int indicesRow[], double elements[])
Adds one Column to basis, can increase size of basis.
void pivotTolerance(double value)
int numberColumns_
Number of Columns in factorization.
CoinIntArrayWithLength nextRow_
Next Row in memory order.
void zeroTolerance(double value)
CoinIntArrayWithLength numberInColumnPlus_
Number in each Column including pivoted.
void updateColumnLSparse(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparse.
void checkSparse()
See if worth going sparse.
int persistenceFlag() const
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
int biasLU() const
L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias.
void updateColumnTransposeLByRow(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by row.
CoinIntArrayWithLength saveColumn_
Columns left to do in a single pivot.
int * numberInRow() const
Number of entries in each row.
double slackValue() const
Whether slack value is +1 or -1.
void separateLinks(int count, bool rowsFirst)
Separate out links with same row/column count.
void clearArrays()
Get rid of all memory.
CoinBigIndex baseL_
Base of L.
CoinBigIndexArrayWithLength startColumnU_
Start of each column in U.
int numberFtranCounts_
We can roll over factorizations.
CoinBigIndex numberCompressions_
Number of compressions done.
bool forrestTomlin() const
true if Forrest Tomlin update, false if PFI
CoinUnsignedIntArrayWithLength workArea2_
Second work area.
int add(CoinBigIndex numberElements, int indicesRow[], int indicesColumn[], double elements[])
Adds given elements to Basis and updates factorization, can increase size of basis.
int * indexRowR_
Row indices for R.
void updateColumnTransposeLSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparse (by Row)
void updateColumnTransposePFI(CoinIndexedVector *region) const
Updates part of column transpose PFI (BTRAN) (before rest)
void goSparse()
makes a row copy of L for speed and to allow very sparse problems
double btranAverageAfterR_
double areaFactor_
How much to multiply areas by.
CoinBigIndexArrayWithLength startColumnR_
Start of columns for R.
void slackValue(double value)
void setNumberRows(int value)
Set number of Rows after factorization.
int denseThreshold() const
Gets dense threshold.
CoinIntArrayWithLength markRow_
Marks rows to be updated.
int status_
Status of factorization.
int numberSlacks_
Number of slacks at beginning of U.
#define COINFACTORIZATION_SHIFT_PER_INT