12 #ifndef CoinFactorization_H
13 #define CoinFactorization_H
14 #define EXTRA_U_SPACE 4
89 int rowIsBasic[],
int columnIsBasic[],
106 const int indicesRow[],
107 const int indicesColumn[],
const double elements[],
116 int estimateNumberElements,
118 int *indicesColumn[],
323 #ifndef COIN_FAST_CODE
461 bool checkBeforeModifying =
false,
462 double acceptablePivot = 1.0e-8);
469 int internalPivotRow);
470 #ifdef ABC_USE_COIN_FACTORIZATION
474 int already = 0)
const;
492 int checkReplacePart2(
int pivotRow,
496 double acceptablePivot = 1.0e-8);
537 void updateColumnTransposeCpu(
CoinIndexedVector ®ionSparse,
int whichCpu)
const;
545 inline bool wantsTableauColumn()
const
550 inline double minimumPivotTolerance()
const
554 inline void minimumPivotTolerance(
double value)
559 inline void setParallelMode(
int value)
561 parallelMode_ = value;
564 inline void setSolveMode(
int value)
567 parallelMode_ |= (value << 2);
570 inline int solveMode()
const
572 return parallelMode_ >> 2;
579 #if ABOCA_LITE_FACTORIZATION
604 bool noPermute =
false)
const;
613 bool noPermuteRegion3 =
false);
657 int add(
int numberElements,
659 int indicesColumn[],
double elements[]);
664 int indicesRow[],
double elements[]);
668 int addRow(
int numberElements,
669 int indicesColumn[],
double elements[]);
679 int replaceRow(
int whichRow,
int numberElements,
680 const int indicesColumn[],
const double elements[]);
682 void emptyRows(
int numberToEmpty,
const int which[]);
688 #if 0 //def CLP_FACTORIZATION_INSTRUMENT
725 int possibleDuplicates = -1);
793 int next = firstCount[count];
794 lastCount[index] = -2 - count;
797 firstCount[count] = index;
798 nextCount[index] = -1;
800 firstCount[count] = index;
801 nextCount[index] = next;
802 lastCount[next] = index;
811 int next = nextCount[index];
812 int last = lastCount[index];
814 nextCount[last] = next;
816 int count = -last - 2;
818 firstCount[count] = next;
821 lastCount[next] = last;
823 nextCount[index] = -2;
824 lastCount[index] = -2;
878 int smallestIndex)
const;
882 int smallestIndex)
const;
886 int smallestIndex)
const;
893 int smallestIndex)
const;
919 int pivotRow,
double alpha);
924 int checkPivot(
double saveFromU,
double oldPivot)
const;
927 #define COINFACTORIZATION_BITS_PER_INT 64
928 #define COINFACTORIZATION_SHIFT_PER_INT 6
929 #define COINFACTORIZATION_MASK_PER_INT 0x3f
931 #define COINFACTORIZATION_BITS_PER_INT 32
932 #define COINFACTORIZATION_SHIFT_PER_INT 5
933 #define COINFACTORIZATION_MASK_PER_INT 0x1f
939 int pivotRowPosition,
940 int pivotColumnPosition,
942 unsigned int workArea2[],
961 int numberInPivotRow = numberInRow[pivotRow] - 1;
963 int numberInPivotColumn = numberInColumn[
pivotColumn] - 1;
964 int endColumn = startColumn + numberInPivotColumn + 1;
966 int startRow = startRowU[pivotRow];
967 int endRow = startRow + numberInPivotRow + 1;
969 if (pivotColumnPosition < 0) {
970 for (pivotColumnPosition = startRow; pivotColumnPosition < endRow; pivotColumnPosition++) {
971 int iColumn = indexColumnU[pivotColumnPosition];
972 if (iColumn != pivotColumn) {
973 saveColumn[put++] = iColumn;
979 for (
int i = startRow; i < pivotColumnPosition; i++) {
980 saveColumn[put++] = indexColumnU[i];
983 assert(pivotColumnPosition < endRow);
984 assert(indexColumnU[pivotColumnPosition] == pivotColumn);
985 pivotColumnPosition++;
986 for (; pivotColumnPosition < endRow; pivotColumnPosition++) {
987 saveColumn[put++] = indexColumnU[pivotColumnPosition];
990 int next = nextRow[pivotRow];
991 int last = lastRow[pivotRow];
993 nextRow[last] = next;
994 lastRow[next] = last;
996 lastRow[pivotRow] = -2;
997 numberInRow[pivotRow] = 0;
1004 printf(
"more memory needed in middle of invert\n");
1015 if (pivotRowPosition < 0) {
1016 for (pivotRowPosition = startColumn; pivotRowPosition < endColumn; pivotRowPosition++) {
1017 int iRow = indexRowU[pivotRowPosition];
1018 if (iRow != pivotRow) {
1019 indexRowL[l] = iRow;
1020 elementL[l] = elementU[pivotRowPosition];
1021 markRow[iRow] =
static_cast< T
>(l - lSave);
1024 int start = startRowU[iRow];
1025 int end = start + numberInRow[iRow];
1028 while (indexColumnU[where] != pivotColumn) {
1036 indexColumnU[where] = indexColumnU[end - 1];
1037 numberInRow[iRow]--;
1045 for (i = startColumn; i < pivotRowPosition; i++) {
1046 int iRow = indexRowU[i];
1048 markRow[iRow] =
static_cast< T
>(l - lSave);
1049 indexRowL[l] = iRow;
1050 elementL[l] = elementU[i];
1053 int start = startRowU[iRow];
1054 int end = start + numberInRow[iRow];
1057 while (indexColumnU[where] != pivotColumn) {
1065 indexColumnU[where] = indexColumnU[end - 1];
1066 numberInRow[iRow]--;
1067 assert(numberInRow[iRow] >= 0);
1070 assert(pivotRowPosition < endColumn);
1071 assert(indexRowU[pivotRowPosition] == pivotRow);
1077 for (; pivotRowPosition < endColumn; pivotRowPosition++) {
1078 int iRow = indexRowU[pivotRowPosition];
1080 markRow[iRow] =
static_cast< T
>(l - lSave);
1081 indexRowL[l] = iRow;
1082 elementL[l] = elementU[pivotRowPosition];
1085 int start = startRowU[iRow];
1086 int end = start + numberInRow[iRow];
1089 while (indexColumnU[where] != pivotColumn) {
1097 indexColumnU[where] = indexColumnU[end - 1];
1098 numberInRow[iRow]--;
1099 assert(numberInRow[iRow] >= 0);
1101 markRow[pivotRow] =
static_cast< T
>(largeInteger);
1105 int *indexL = &indexRowL[lSave];
1111 for (j = 0; j < numberInPivotColumn; j++) {
1112 multipliersL[j] *= pivotMultiplier;
1116 for (iErase = 0; iErase < increment2 * numberInPivotRow;
1118 workArea2[iErase] = 0;
1120 int added = numberInPivotRow * numberInPivotColumn;
1121 unsigned int *temp2 = workArea2;
1126 for (jColumn = 0; jColumn < numberInPivotRow; jColumn++) {
1127 int iColumn = saveColumn[jColumn];
1128 int startColumn = startColumnU[iColumn];
1129 int endColumn = startColumn + numberInColumn[iColumn];
1130 int iRow = indexRowU[startColumn];
1133 int put = startColumn;
1134 int positionLargest = -1;
1139 int mark = markRow[iRow];
1141 if (mark == largeInteger + 1) {
1142 largest = fabs(value);
1143 positionLargest = put;
1145 checkLargest =
false;
1149 checkLargest =
true;
1150 if (mark != largeInteger) {
1156 temp2[word] = temp2[word] | (1 << bit);
1159 thisPivotValue = value;
1163 for (i = startColumn + 1; i < endColumn; i++) {
1164 iRow = indexRowU[i];
1165 value = elementU[i];
1166 int mark = markRow[iRow];
1168 if (mark == largeInteger + 1) {
1170 indexRowU[put] = iRow;
1171 elementU[put] = value;
1173 double absValue = fabs(value);
1175 if (absValue > largest) {
1177 positionLargest = put;
1181 }
else if (mark != largeInteger) {
1187 temp2[word] = temp2[word] | (1 << bit);
1190 thisPivotValue = value;
1194 elementU[put] = elementU[startColumn];
1195 indexRowU[put] = indexRowU[startColumn];
1196 if (positionLargest == startColumn) {
1197 positionLargest = put;
1200 elementU[startColumn] = thisPivotValue;
1201 indexRowU[startColumn] = pivotRow;
1204 numberInColumn[iColumn] = put - startColumn;
1206 numberInColumnPlus[iColumn]++;
1207 startColumnU[iColumn]++;
1209 int next = nextColumn[iColumn];
1212 space = startColumnU[next] - put - numberInColumnPlus[next];
1214 if (numberInPivotColumn > space) {
1220 if (positionLargest >= 0)
1221 positionLargest = positionLargest + startColumnU[iColumn] - startColumn;
1222 startColumn = startColumnU[iColumn];
1223 put = startColumn + numberInColumn[iColumn];
1228 for (j = 0; j < numberInPivotColumn; j++) {
1229 value = work[j] - thisPivotValue * multipliersL[j];
1230 double absValue = fabs(value);
1232 if (absValue > tolerance) {
1235 elementU[put] = value;
1236 indexRowU[put] = indexL[j];
1237 if (absValue > largest) {
1239 positionLargest = put;
1248 if (temp2[word] & (1 << bit)) {
1251 int start = startRowU[iRow];
1252 int end = start + numberInRow[iRow];
1255 while (indexColumnU[where] != iColumn) {
1263 indexColumnU[where] = indexColumnU[end - 1];
1264 numberInRow[iRow]--;
1270 temp2[word] = temp2[word] | (1 << bit);
1274 numberInColumn[iColumn] = put - startColumn;
1276 if (positionLargest >= 0) {
1277 value = elementU[positionLargest];
1278 iRow = indexRowU[positionLargest];
1279 elementU[positionLargest] = elementU[startColumn];
1280 indexRowU[positionLargest] = indexRowU[startColumn];
1281 elementU[startColumn] = value;
1282 indexRowU[startColumn] = iRow;
1290 temp2 += increment2;
1293 unsigned int *putBase = workArea2;
1302 unsigned int *putThis = putBase;
1303 int iRow = indexL[i];
1309 for (jColumn = 0; jColumn < numberInPivotRow; jColumn++) {
1310 unsigned int test = *putThis;
1312 putThis += increment2;
1313 test = 1 - ((test >> bit) & 1);
1316 int next = nextRow[iRow];
1319 space = startRowU[next] - startRowU[iRow];
1320 number += numberInRow[iRow];
1321 if (space < number) {
1328 next = nextRow[iRow];
1329 number = numberInRow[iRow];
1330 int end = startRowU[iRow] + number;
1331 int saveIndex = indexColumnU[startRowU[next]];
1334 for (jColumn = 0; jColumn < numberInPivotRow; jColumn++) {
1335 unsigned int test = *putThis;
1337 putThis += increment2;
1338 test = 1 - ((test >> bit) & 1);
1339 indexColumnU[end] = saveColumn[jColumn];
1343 indexColumnU[startRowU[next]] = saveIndex;
1344 markRow[iRow] =
static_cast< T
>(largeInteger + 1);
1345 number = end - startRowU[iRow];
1346 numberInRow[iRow] = number;
1354 for (bit = 0; i < numberInPivotColumn; i++, bit++) {
1355 unsigned int *putThis = putBase;
1356 int iRow = indexL[i];
1362 for (jColumn = 0; jColumn < numberInPivotRow; jColumn++) {
1363 unsigned int test = *putThis;
1365 putThis += increment2;
1366 test = 1 - ((test >> bit) & 1);
1369 int next = nextRow[iRow];
1372 space = startRowU[next] - startRowU[iRow];
1373 number += numberInRow[iRow];
1374 if (space < number) {
1381 next = nextRow[iRow];
1382 number = numberInRow[iRow];
1383 int end = startRowU[iRow] + number;
1386 saveIndex = indexColumnU[startRowU[next]];
1389 for (jColumn = 0; jColumn < numberInPivotRow; jColumn++) {
1390 unsigned int test = *putThis;
1392 putThis += increment2;
1393 test = 1 - ((test >> bit) & 1);
1395 indexColumnU[end] = saveColumn[jColumn];
1398 indexColumnU[startRowU[next]] = saveIndex;
1399 markRow[iRow] =
static_cast< T
>(largeInteger + 1);
1400 number = end - startRowU[iRow];
1401 numberInRow[iRow] = number;
1405 markRow[pivotRow] =
static_cast< T
>(largeInteger + 1);
1423 #ifndef COIN_FAST_CODE
1428 #define slackValue_ -1.0
1658 #define collectStatistics_ 1
1678 #if ABOCA_LITE_FACTORIZATION
1692 #ifdef ABC_USE_COIN_FACTORIZATION
1699 #ifdef INTEL_COMPILER
1700 #define COIN_FACTORIZATION_DENSE_CODE 3
1702 #ifdef COIN_HAS_LAPACK
1703 #ifndef COIN_FACTORIZATION_DENSE_CODE
1704 #define COIN_FACTORIZATION_DENSE_CODE 1
1707 #ifdef COIN_FACTORIZATION_DENSE_CODE
1712 typedef const int cipfint;
1717 #ifdef UGLY_COIN_FACTOR_CODING
1718 #define FAC_UNSET (FAC_SET + 1)
1722 int startColumnThis = startColumn[iPivotColumn];
1723 int endColumn = startColumnThis + numberDoColumn + 1;
1725 int startRowThis = startRow[iPivotRow];
1726 int endRow = startRowThis + numberDoRow + 1;
1727 if (pivotColumnPosition < 0) {
1728 for (pivotColumnPosition = startRowThis; pivotColumnPosition < endRow; pivotColumnPosition++) {
1729 int iColumn = indexColumn[pivotColumnPosition];
1730 if (iColumn != iPivotColumn) {
1731 saveColumn[put++] = iColumn;
1737 for (
int i = startRowThis; i < pivotColumnPosition; i++) {
1738 saveColumn[put++] = indexColumn[i];
1741 assert(pivotColumnPosition < endRow);
1742 assert(indexColumn[pivotColumnPosition] == iPivotColumn);
1743 pivotColumnPosition++;
1744 for (; pivotColumnPosition < endRow; pivotColumnPosition++) {
1745 saveColumn[put++] = indexColumn[pivotColumnPosition];
1748 int next = nextRow[iPivotRow];
1749 int last = lastRow[iPivotRow];
1751 nextRow[last] = next;
1752 lastRow[next] = last;
1753 nextRow[iPivotRow] = numberGoodU_;
1754 lastRow[iPivotRow] = -2;
1755 numberInRow[iPivotRow] = 0;
1760 if (l + numberDoColumn > lengthAreaL_) {
1762 if ((messageLevel_ & 4) != 0)
1763 printf(
"more memory needed in middle of invert\n");
1769 int *startColumnL = startColumnL_.array();
1770 startColumnL[numberGoodL_] = l;
1772 startColumnL[numberGoodL_] = l + numberDoColumn;
1773 lengthL_ += numberDoColumn;
1774 if (pivotRowPosition < 0) {
1775 for (pivotRowPosition = startColumnThis; pivotRowPosition < endColumn; pivotRowPosition++) {
1776 int iRow = indexRow[pivotRowPosition];
1777 if (iRow != iPivotRow) {
1778 indexRowL[l] = iRow;
1779 elementL[l] = element[pivotRowPosition];
1780 markRow[iRow] = l - lSave;
1783 int start = startRow[iRow];
1784 int end = start + numberInRow[iRow];
1787 while (indexColumn[where] != iPivotColumn) {
1795 indexColumn[where] = indexColumn[end - 1];
1796 numberInRow[iRow]--;
1804 for (i = startColumnThis; i < pivotRowPosition; i++) {
1805 int iRow = indexRow[i];
1807 markRow[iRow] = l - lSave;
1808 indexRowL[l] = iRow;
1809 elementL[l] = element[i];
1812 int start = startRow[iRow];
1813 int end = start + numberInRow[iRow];
1816 while (indexColumn[where] != iPivotColumn) {
1824 indexColumn[where] = indexColumn[end - 1];
1825 numberInRow[iRow]--;
1826 assert(numberInRow[iRow] >= 0);
1829 assert(pivotRowPosition < endColumn);
1830 assert(indexRow[pivotRowPosition] == iPivotRow);
1834 pivotRegion_.array()[numberGoodU_] = pivotMultiplier;
1836 for (; pivotRowPosition < endColumn; pivotRowPosition++) {
1837 int iRow = indexRow[pivotRowPosition];
1839 markRow[iRow] = l - lSave;
1840 indexRowL[l] = iRow;
1841 elementL[l] = element[pivotRowPosition];
1844 int start = startRow[iRow];
1845 int end = start + numberInRow[iRow];
1848 while (indexColumn[where] != iPivotColumn) {
1856 indexColumn[where] = indexColumn[end - 1];
1857 numberInRow[iRow]--;
1858 assert(numberInRow[iRow] >= 0);
1860 markRow[iPivotRow] = FAC_SET;
1862 numberInColumn[iPivotColumn] = 0;
1864 int *indexL = &indexRowL[lSave];
1870 for (j = 0; j < numberDoColumn; j++) {
1871 multipliersL[j] *= pivotMultiplier;
1875 for (iErase = 0; iErase < increment2 * numberDoRow;
1877 workArea2[iErase] = 0;
1879 int added = numberDoRow * numberDoColumn;
1880 unsigned int *temp2 = workArea2;
1881 int *nextColumn = nextColumn_.array();
1885 for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
1886 int iColumn = saveColumn[jColumn];
1887 int startColumnThis = startColumn[iColumn];
1888 int endColumn = startColumnThis + numberInColumn[iColumn];
1889 int iRow = indexRow[startColumnThis];
1892 int put = startColumnThis;
1893 int positionLargest = -1;
1898 int mark = markRow[iRow];
1900 if (mark == FAC_UNSET) {
1901 largest = fabs(value);
1902 positionLargest = put;
1904 checkLargest =
false;
1908 checkLargest =
true;
1909 if (mark != FAC_SET) {
1911 workArea[mark] = value;
1915 temp2[word] = temp2[word] | (1 << bit);
1918 thisPivotValue = value;
1922 for (i = startColumnThis + 1; i < endColumn; i++) {
1925 int mark = markRow[iRow];
1927 if (mark == FAC_UNSET) {
1929 indexRow[put] = iRow;
1930 element[put] = value;
1932 double absValue = fabs(value);
1934 if (absValue > largest) {
1936 positionLargest = put;
1940 }
else if (mark != FAC_SET) {
1942 workArea[mark] = value;
1946 temp2[word] = temp2[word] | (1 << bit);
1949 thisPivotValue = value;
1953 element[put] = element[startColumnThis];
1954 indexRow[put] = indexRow[startColumnThis];
1955 if (positionLargest == startColumnThis) {
1956 positionLargest = put;
1959 element[startColumnThis] = thisPivotValue;
1960 indexRow[startColumnThis] = iPivotRow;
1963 numberInColumn[iColumn] = put - startColumnThis;
1964 int *numberInColumnPlus = numberInColumnPlus_.array();
1965 numberInColumnPlus[iColumn]++;
1966 startColumn[iColumn]++;
1968 int next = nextColumn[iColumn];
1971 space = startColumn[next] - put - numberInColumnPlus[next];
1973 if (numberDoColumn > space) {
1975 if (!getColumnSpace(iColumn, numberDoColumn)) {
1979 positionLargest = positionLargest + startColumn[iColumn] - startColumnThis;
1980 startColumnThis = startColumn[iColumn];
1981 put = startColumnThis + numberInColumn[iColumn];
1983 double tolerance = zeroTolerance_;
1985 int *nextCount = nextCount_.array();
1986 for (j = 0; j < numberDoColumn; j++) {
1987 value = workArea[j] - thisPivotValue * multipliersL[j];
1988 double absValue = fabs(value);
1990 if (absValue > tolerance) {
1992 element[put] = value;
1993 indexRow[put] = indexL[j];
1994 if (absValue > largest) {
1996 positionLargest = put;
2005 if (temp2[word] & (1 << bit)) {
2008 int start = startRow[iRow];
2009 int end = start + numberInRow[iRow];
2012 while (indexColumn[where] != iColumn) {
2020 indexColumn[where] = indexColumn[end - 1];
2021 numberInRow[iRow]--;
2027 temp2[word] = temp2[word] | (1 << bit);
2031 numberInColumn[iColumn] = put - startColumnThis;
2033 if (positionLargest >= 0) {
2034 value = element[positionLargest];
2035 iRow = indexRow[positionLargest];
2036 element[positionLargest] = element[startColumnThis];
2037 indexRow[positionLargest] = indexRow[startColumnThis];
2038 element[startColumnThis] = value;
2039 indexRow[startColumnThis] = iRow;
2042 if (nextCount[iColumn + numberRows_] != -2) {
2044 deleteLink(iColumn + numberRows_);
2045 addLink(iColumn + numberRows_, numberInColumn[iColumn]);
2047 temp2 += increment2;
2050 unsigned int *putBase = workArea2;
2059 unsigned int *putThis = putBase;
2060 int iRow = indexL[i];
2066 for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
2067 unsigned int test = *putThis;
2069 putThis += increment2;
2070 test = 1 - ((test >> bit) & 1);
2073 int next = nextRow[iRow];
2076 space = startRow[next] - startRow[iRow];
2077 number += numberInRow[iRow];
2078 if (space < number) {
2079 if (!getRowSpace(iRow, number)) {
2085 next = nextRow[iRow];
2086 number = numberInRow[iRow];
2087 int end = startRow[iRow] + number;
2088 int saveIndex = indexColumn[startRow[next]];
2091 for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
2092 unsigned int test = *putThis;
2094 putThis += increment2;
2095 test = 1 - ((test >> bit) & 1);
2096 indexColumn[end] = saveColumn[jColumn];
2100 indexColumn[startRow[next]] = saveIndex;
2101 markRow[iRow] = FAC_UNSET;
2102 number = end - startRow[iRow];
2103 numberInRow[iRow] = number;
2105 addLink(iRow, number);
2111 for (bit = 0; i < numberDoColumn; i++, bit++) {
2112 unsigned int *putThis = putBase;
2113 int iRow = indexL[i];
2119 for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
2120 unsigned int test = *putThis;
2122 putThis += increment2;
2123 test = 1 - ((test >> bit) & 1);
2126 int next = nextRow[iRow];
2129 space = startRow[next] - startRow[iRow];
2130 number += numberInRow[iRow];
2131 if (space < number) {
2132 if (!getRowSpace(iRow, number)) {
2138 next = nextRow[iRow];
2139 number = numberInRow[iRow];
2140 int end = startRow[iRow] + number;
2143 saveIndex = indexColumn[startRow[next]];
2146 for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
2147 unsigned int test = *putThis;
2149 putThis += increment2;
2150 test = 1 - ((test >> bit) & 1);
2152 indexColumn[end] = saveColumn[jColumn];
2155 indexColumn[startRow[next]] = saveIndex;
2156 markRow[iRow] = FAC_UNSET;
2157 number = end - startRow[iRow];
2158 numberInRow[iRow] = number;
2160 addLink(iRow, number);
2162 markRow[iPivotRow] = FAC_UNSET;
2164 deleteLink(iPivotRow);
2165 deleteLink(iPivotColumn + numberRows_);
2166 totalElements_ += added;
bool getColumnSpace(int iColumn, int extraNeeded)
Gets space for one Column with given length, may have to do compression (returns True if successful)...
int lengthAreaL() const
Returns length of L area.
int numberGoodU_
Number factorized in U (not row singletons)
double slackValue() const
Whether slack value is +1 or -1.
int baseL() const
Base of L.
int factorDense()
Does dense phase of factorization return code is <0 error, 0= finished.
int getColumnSpaceIterate(int iColumn, double value, int iRow)
getColumnSpaceIterate.
double ftranCountAfterL_
Pivot tolerance.
int numberElementsR() const
Returns number in R area.
int maximumColumnsExtra()
Maximum number of Columns after iterating.
int addColumn(int numberElements, int indicesRow[], double elements[])
Adds one Column to basis, can increase size of basis.
void updateColumnTransposeLSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparse (by Row)
CoinIntArrayWithLength startColumnL_
Start of each column in L.
int numberBtranCounts_
Pivot tolerance.
int lengthAreaL_
Length of area reserved for L.
int lengthAreaU_
Length of area reserved for U.
void updateColumnTransposeUSparsish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when sparsish, assumes index is sorted i.e.
void updateColumnTransposePFI(CoinIndexedVector *region) const
Updates part of column transpose PFI (BTRAN) (before rest)
void setBiasLU(int value)
Returns number of dense rows.
int numberForrestTomlin() const
Length of FT vector.
void gutsOfCopy(const CoinFactorization &other)
See if worth going sparse.
int lengthR_
Length of R stuff.
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 * indexColumnL() const
Index of column in row for L.
double zeroTolerance_
Zero tolerance.
int sparseThreshold_
Below this use sparse technology - if 0 then no L row copy.
int factorizePart1(int numberRows, int numberColumns, int 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.
CoinIntArrayWithLength saveColumn_
Columns left to do in a single pivot.
void clearArrays()
Get rid of all memory.
CoinUnsignedIntArrayWithLength workArea2_
Second work area.
void updateColumnTransposeUDensish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when densish, assumes index is sorted i.e.
int * pivotColumn() const
Returns address of pivotColumn region (also used for permuting)
double ftranCountAfterU_
Pivot tolerance.
void checkConsistency()
Checks that row and column copies look OK.
int numberTrials_
0 - no increasing rows - no permutations, 1 - no increasing rows but permutations 2 - increasing rows...
int deleteColumn(int Row)
Deletes one Column from basis, returns rank.
void preProcess(int state, int possibleDuplicates=-1)
PreProcesses raw triplet data.
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 numberL() const
Number in L.
void addLink(int index, int count)
Adds a link in chain of equal counts.
CoinIntArrayWithLength indexColumnU_
Base address for U (may change)
CoinFactorizationDouble * elementR_
Elements of R.
CoinIntArrayWithLength nextRow_
Next Row in memory order.
bool pivotRowSingleton(int pivotRow, int pivotColumn)
Does one pivot on Row Singleton in factorization.
double btranCountAfterR_
Pivot tolerance.
int numberColumns() const
Total number of columns in factorization.
void gutsOfDestructor(int type=1)
The real work of constructors etc 0 just scalars, 1 bit normal.
#define COINFACTORIZATION_BITS_PER_INT
int numberColumns_
Number of Columns in factorization.
int * indexRowU() const
Row indices of U.
int biggerDimension_
Larger of row and column size.
int sparseThreshold2_
And one for "sparsish".
bool getRowSpace(int iRow, int extraNeeded)
Gets space for one Row with given length, may have to do compression (returns True if successful)...
int maximumU_
Maximum space used in U.
void updateColumnTransposeRSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when sparse.
int factorElements_
Number of elements after factorization.
int numberElementsU() const
Returns number in U area.
double ftranCountAfterR_
Pivot tolerance.
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 indexColumnL_
Index of column in row for L.
int sparseThreshold() const
get sparse threshold
int deleteRow(int Row)
Deletes one Row from basis, returns rank.
int * array() const
Get Array.
int updateColumnUDensish(double *COIN_RESTRICT region, int *COIN_RESTRICT regionIndex) const
Updates part of column (FTRANU)
int * indexRowL() const
Row indices of L.
double ftranAverageAfterU_
Pivot tolerance.
void setPersistenceFlag(int value)
Returns number of dense rows.
CoinFactorizationDoubleArrayWithLength elementU_
Elements of U.
CoinIntArrayWithLength sparse_
Sparse regions.
int * startColumnL() const
Start of each column in L.
void updateColumnTransposeUByColumn(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) by column assumes index is sorted i.e.
CoinFactorizationDoubleArrayWithLength workArea_
First work area.
Sparse Matrix Base Class.
CoinIntArrayWithLength permute_
Permutation vector for pivot row order.
double ftranAverageAfterL_
While these are average ratios collected over last period.
bool forrestTomlin() const
true if Forrest Tomlin update, false if PFI
void replaceColumnU(CoinIndexedVector *regionSparse, int *deleted, int internalPivotRow)
Combines BtranU and delete elements If deleted is NULL then delete elements otherwise store where ele...
void updateColumnUSparse(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparse.
void setNumberRows(int value)
Set number of Rows after factorization.
CoinIntArrayWithLength lastCount_
Previous Row/Column with count.
bool reorderU()
Reorders U so contiguous and in order (if there is space) Returns true if it could.
CoinFactorization()
Default constructor.
bool collectStatistics() const
For statistics.
void updateColumnTransposeUSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANU) when sparse, assumes index is sorted i.e.
double adjustedAreaFactor() const
Returns areaFactor but adjusted for dense.
bool spaceForForrestTomlin() const
True if FT update and space.
CoinIntArrayWithLength numberInColumnPlus_
Number in each Column including pivoted.
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...
void areaFactor(double value)
Returns status.
bool pivotOneOtherRow(int pivotRow, int pivotColumn)
Pivots when just one other row so faster?
bool pivot(int pivotRow, int pivotColumn, int pivotRowPosition, int pivotColumnPosition, CoinFactorizationDouble work[], unsigned int workArea2[], int increment2, T markRow[], int largeInteger)
Gets space for a factorization, called by constructors.
void goSparse()
makes a row copy of L for speed and to allow very sparse problems
int numberColumnsExtra_
Number of Columns after iterating.
double ftranCountInput_
Below are all to collect.
CoinIntArrayWithLength startColumnR_
Start of columns for R.
void updateColumnUSparsish(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparsish.
int * startRowL() const
Start of each row in L.
CoinFactorizationDouble * elementByRowL() const
Elements in L (row copy)
void updateColumnLDensish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when densish.
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...
double * denseAreaAddress_
Dense area - actually used (for alignment etc)
int maximumPivots_
Maximum number of pivots before factorization.
CoinIntArrayWithLength startRowU_
Start of each Row as pointer.
int maximumColumnsExtra_
Maximum number of Columns after iterating.
CoinFactorizationDoubleArrayWithLength pivotRegion_
Inverses of pivot values.
CoinIntArrayWithLength pivotColumn_
Pivot order for each Column.
void updateColumnTransposeU(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU), assumes index is sorted i.e.
CoinFactorizationDouble * elementU() const
Elements of U.
void updateColumnTransposeLDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by column.
CoinIntArrayWithLength indexRowL_
Row indices of L.
double btranAverageAfterR_
Pivot tolerance.
double * denseArea_
Dense area.
double CoinFactorizationDouble
CoinIntArrayWithLength nextColumn_
Next Column in memory order.
int * lastRow() const
Returns address of lastRow region.
void gutsOfInitialize(int type)
1 bit - tolerances etc, 2 more, 4 dummy arrays
int maximumPivots() const
Maximum number of pivots between factorizations.
int biasLU() const
L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias.
bool getColumnSpaceIterateR(int iColumn, double value, int iRow)
getColumnSpaceIterateR.
void updateColumnTransposeL(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL)
void updateTwoColumnsTranspose(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2, CoinIndexedVector *regionSparse3, int type) const
Updates two columns (BTRAN) from regionSparse2 and 3 regionSparse starts as zero and is zero at end N...
void setNumberElementsU(int value)
Setss number in U area.
CoinIntArrayWithLength numberInRow_
Number in each Row.
void sort() const
Debug - sort so can compare.
CoinFactorizationDouble * array() const
Get Array.
#define COINFACTORIZATION_MASK_PER_INT
void updateColumnTransposeR(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR)
CoinFactorizationDoubleArrayWithLength elementL_
Elements of L.
friend void CoinFactorizationUnitTest(const std::string &mpsDir)
#define COINFACTORIZATION_SHIFT_PER_INT
int updateColumnFT(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2)
Updates one column (FTRAN) from regionSparse2 Tries to do FT update number returned is negative if no...
int * indexRowR_
Row indices for R.
int maximumRowsExtra() const
Maximum of Rows after iterating.
double slackValue_
Whether slack value is +1 or -1.
double areaFactor() const
Whether larger areas needed.
double btranCountAfterL_
Pivot tolerance.
void checkSparse()
See if worth going sparse.
int * numberInColumn() const
Number of entries in each column.
int * permute() const
Returns address of permute region.
int numberSlacks_
Number of slacks at beginning of U.
void resetStatistics()
Reset all sparsity etc statistics.
int * numberInRow() const
Number of entries in each row.
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 setCollectStatistics(bool onOff) const
For statistics.
void updateColumnRFT(CoinIndexedVector *region, int *indexIn)
Updates part of column (FTRANR) with FT update.
CoinIntArrayWithLength firstCount_
First Row/Column with count of k, can tell which by offset - Rows then Columns.
int numberElements() const
Total number of elements in factorization.
double getAccuracyCheck() const
Returns status.
double btranCountInput_
Pivot tolerance.
CoinIntArrayWithLength convertRowToColumnU_
Converts rows to columns in U.
double btranCountAfterU_
Pivot tolerance.
int factorSparseSmall()
Does sparse phase of factorization (for smaller problems) return code is <0 error, 0= finished.
int lengthU_
Base of U is always 0.
CoinIntArrayWithLength markRow_
Marks rows to be updated.
~CoinFactorization()
Destructor.
int factorize(const CoinPackedMatrix &matrix, int rowIsBasic[], int columnIsBasic[], double areaFactor=0.0)
When part of LP - given by basic variables.
CoinFactorizationDouble * pivotRegion() const
Returns address of pivot region.
void cleanup()
Cleans up at end of factorization.
CoinIntArrayWithLength pivotRowL_
Pivots for L.
CoinIntArrayWithLength lastRow_
Previous Row in memory order.
int numberPivots_
Number pivots since last factorization.
int * permuteBack() const
Returns address of permuteBack region.
int denseThreshold_
Dense threshold.
int numberDense() const
Returns number of dense rows.
CoinIntArrayWithLength nextCount_
Next Row/Column with count.
int numberCompressions_
Number of compressions done.
int factor()
Does most of factorization.
void separateLinks(int count, bool rowsFirst)
Separate out links with same row/column count.
void updateColumnL(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL)
int numberCompressions() const
Number of compressions done.
int status_
Status of factorization.
void updateColumnTransposeLByRow(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by row.
int numberRowsExtra() const
Number of Rows after iterating.
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 factorSparseLarge()
Does sparse phase of factorization (for larger problems) return code is <0 error, 0= finished...
int numberFtranCounts_
We can roll over factorizations.
int pivots() const
Returns number of pivots since factorization.
void setPivots(int value)
Sets number of pivots since factorization.
CoinIntArrayWithLength numberInColumn_
Number in each Column.
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 totalElements_
Number of elements in U (to go) or while iterating total overall.
void updateColumnR(CoinIndexedVector *region) const
Updates part of column (FTRANR) without FT update.
double maximumCoefficient() const
Returns maximum absolute value in factorization.
double areaFactor_
How much to multiply areas by.
void updateColumnU(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANU)
bool getRowSpaceIterate(int iRow, int extraNeeded)
Gets space for one Row with given length while iterating, may have to do compression (returns True i...
int numberElementsL() const
Returns number in L area.
int numberRows_
Number of Rows in factorization.
int biasLU_
L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias.
int * startColumnU() const
Start of each column in U.
double btranAverageAfterU_
Pivot tolerance.
int factorSparse()
Does sparse phase of factorization return code is <0 error, 0= finished.
int status() const
Returns status.
int numberGoodColumns() const
Number of good columns in factorization.
void updateOneColumnTranspose(CoinIndexedVector *regionWork, int &statistics) const
Part of twocolumnsTranspose.
void setDenseThreshold(int value)
Sets dense threshold.
int checkPivot(double saveFromU, double oldPivot) const
Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular. ...
void updateColumnPFI(CoinIndexedVector *regionSparse) const
Updates part of column PFI (FTRAN) (after rest)
int numberRows() const
Number of Rows after factorization.
void emptyRows(int numberToEmpty, const int which[])
Takes out all entries for given rows.
#define collectStatistics_
For statistics.
int add(int numberElements, int indicesRow[], int indicesColumn[], double elements[])
Adds given elements to Basis and updates factorization, can increase size of basis.
This deals with Factorization and Updates.
int numberGoodL_
Number factorized in L.
double pivotTolerance() const
Pivot tolerance.
double btranAverageAfterL_
Pivot tolerance.
CoinIntArrayWithLength permuteBack_
DePermutation vector for pivot row order.
int restoreFactorization(const char *file, bool factor=false)
Debug - restore from file - 0 if no error on file.
double pivotTolerance_
Pivot tolerance.
CoinIntArrayWithLength startRowL_
Start of each row in L.
void updateColumnTransposeRDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when dense.
double relaxCheck_
Relax check on accuracy in replaceColumn.
int denseThreshold() const
Gets dense threshold.
void almostDestructor()
Delete all stuff (leaves as after CoinFactorization())
CoinFactorizationDouble * version.
void setStatus(int value)
Sets status.
CoinIntArrayWithLength indexRowU_
Row indices of U.
bool doForrestTomlin_
true if Forrest Tomlin update, false if PFI
CoinIntArrayWithLength lastColumn_
Previous Column in memory order.
void relaxAccuracyCheck(double value)
Allows change of pivot accuracy check 1.0 == none >1.0 relaxed.
int messageLevel_
Detail in messages.
int saveFactorization(const char *file) const
Debug - save on file - 0 if no error.
void show_self() const
Debug show object (shows one representation)
int maximumRowsExtra_
Maximum number of Rows after iterating.
double zeroTolerance() const
Zero tolerance.
int numberDense_
Number of dense rows.
int messageLevel() const
Level of detail of messages.
int factorizePart2(int permutation[], int exactNumberElements)
This is part two of factorization Arrays belong to factorization and were returned by part 1 If statu...
double ftranAverageAfterR_
Pivot tolerance.
int numberRowsExtra_
Number of Rows after iterating.
void updateColumnLSparse(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparse.
CoinIntArrayWithLength pivotColumnBack_
Inverse Pivot order for each Column.
void deleteLink(int index)
Deletes a link in chain of equal counts.
int lengthAreaU() const
Returns length of U area.
CoinFactorizationDoubleArrayWithLength elementByRowL_
Elements in L (row copy)
bool pivotColumnSingleton(int pivotRow, int pivotColumn)
Does one pivot on Column Singleton in factorization.
int lengthAreaR_
length of area reserved for R
int * densePermute_
Dense permutation.
CoinFactorization & operator=(const CoinFactorization &other)
= copy
CoinIntArrayWithLength startColumnU_
Start of each column in U.
void updateColumnLSparsish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparsish.
int addRow(int numberElements, int indicesColumn[], double elements[])
Adds one Row to basis, can increase size of basis.
int * pivotColumnBack() const
Returns address of pivotColumnBack region (also used for permuting) Now uses firstCount to save memor...
void getAreas(int numberRows, int numberColumns, int maximumL, int maximumU)
Gets space for a factorization, called by constructors.
double conditionNumber() const
Condition number - product of pivots after factorization.
void updateColumnTransposeLSparsish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparsish by row.
int updateColumnTranspose(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const
Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - i...
void setForrestTomlin(bool value)
Returns status.