Osi 0.107.7

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CoinFactorization.hpp
Go to the documentation of this file.
1 /* $Id: CoinFactorization.hpp 1767 2015-01-05 12:36:13Z forrest $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5
6 /*
7 Authors
8
9 John Forrest
10
11 */
12 #ifndef CoinFactorization_H
13 #define CoinFactorization_H
14 //#define COIN_ONE_ETA_COPY 100
15
16 #include <iostream>
17 #include <string>
18 #include <cassert>
19 #include <cstdio>
20 #include <cmath>
21 #include "CoinTypes.hpp"
22 #include "CoinIndexedVector.hpp"
23
24 class CoinPackedMatrix;
50 class CoinFactorization {
51 friend void CoinFactorizationUnitTest( const std::string & mpsDir );
52
53 public:
54
57 CoinFactorization ( );
60 CoinFactorization ( const CoinFactorization &other);
61
63 ~CoinFactorization ( );
65 void almostDestructor();
67 void show_self ( ) const;
69 int saveFactorization (const char * file ) const;
73 int restoreFactorization (const char * file , bool factor=false) ;
75 void sort ( ) const;
77 CoinFactorization & operator = ( const CoinFactorization & other );
79
89 int factorize ( const CoinPackedMatrix & matrix,
90 int rowIsBasic[], int columnIsBasic[] ,
91 double areaFactor = 0.0 );
102 int factorize ( int numberRows,
103 int numberColumns,
104 CoinBigIndex numberElements,
105 CoinBigIndex maximumL,
106 CoinBigIndex maximumU,
107 const int indicesRow[],
108 const int indicesColumn[], const double elements[] ,
109 int permutation[],
110 double areaFactor = 0.0);
115 int factorizePart1 ( int numberRows,
116 int numberColumns,
117 CoinBigIndex estimateNumberElements,
118 int * indicesRow[],
119 int * indicesColumn[],
120 CoinFactorizationDouble * elements[],
121 double areaFactor = 0.0);
128 int factorizePart2 (int permutation[],int exactNumberElements);
130 double conditionNumber() const;
131
133
136 inline int status ( ) const {
138 return status_;
139 }
141 inline void setStatus ( int value)
142 { status_=value; }
144 inline int pivots ( ) const {
145 return numberPivots_;
146 }
148 inline void setPivots ( int value )
149 { numberPivots_=value; }
151 inline int *permute ( ) const {
152 return permute_.array();
153 }
155 inline int *pivotColumn ( ) const {
156 return pivotColumn_.array();
157 }
159 inline CoinFactorizationDouble *pivotRegion ( ) const {
160 return pivotRegion_.array();
161 }
163 inline int *permuteBack ( ) const {
164 return permuteBack_.array();
165 }
167 inline int *lastRow ( ) const {
168 return lastRow_.array();
169 }
172 inline int *pivotColumnBack ( ) const {
173 //return firstCount_.array();
174 return pivotColumnBack_.array();
175 }
177 inline CoinBigIndex * startRowL() const
178 { return startRowL_.array();}
179
181 inline CoinBigIndex * startColumnL() const
182 { return startColumnL_.array();}
183
185 inline int * indexColumnL() const
186 { return indexColumnL_.array();}
187
189 inline int * indexRowL() const
190 { return indexRowL_.array();}
191
193 inline CoinFactorizationDouble * elementByRowL() const
194 { return elementByRowL_.array();}
195
197 inline int numberRowsExtra ( ) const {
198 return numberRowsExtra_;
199 }
201 inline void setNumberRows(int value)
202 { numberRows_ = value; }
204 inline int numberRows ( ) const {
205 return numberRows_;
206 }
208 inline CoinBigIndex numberL() const
209 { return numberL_;}
210
212 inline CoinBigIndex baseL() const
213 { return baseL_;}
215 inline int maximumRowsExtra ( ) const {
216 return maximumRowsExtra_;
217 }
219 inline int numberColumns ( ) const {
220 return numberColumns_;
221 }
223 inline int numberElements ( ) const {
224 return totalElements_;
225 }
227 inline int numberForrestTomlin ( ) const {
228 return numberInColumn_.array()[numberColumnsExtra_];
229 }
231 inline int numberGoodColumns ( ) const {
232 return numberGoodU_;
233 }
235 inline double areaFactor ( ) const {
236 return areaFactor_;
237 }
238 inline void areaFactor ( double value ) {
239 areaFactor_=value;
240 }
242 double adjustedAreaFactor() const;
244 inline void relaxAccuracyCheck(double value)
245 { relaxCheck_ = value;}
246 inline double getAccuracyCheck() const
247 { return relaxCheck_;}
249 inline int messageLevel ( ) const {
250 return messageLevel_ ;
251 }
252 void messageLevel ( int value );
254 inline int maximumPivots ( ) const {
255 return maximumPivots_ ;
256 }
257 void maximumPivots ( int value );
258
260 inline int denseThreshold() const
261 { return denseThreshold_;}
263 inline void setDenseThreshold(int value)
264 { denseThreshold_ = value;}
266 inline double pivotTolerance ( ) const {
267 return pivotTolerance_ ;
268 }
269 void pivotTolerance ( double value );
271 inline double zeroTolerance ( ) const {
272 return zeroTolerance_ ;
273 }
274 void zeroTolerance ( double value );
275 #ifndef COIN_FAST_CODE
276 inline double slackValue ( ) const {
278 return slackValue_ ;
279 }
280 void slackValue ( double value );
281 #endif
282 double maximumCoefficient() const;
285 inline bool forrestTomlin() const
286 { return doForrestTomlin_;}
287 inline void setForrestTomlin(bool value)
288 { doForrestTomlin_=value;}
290 inline bool spaceForForrestTomlin() const
291 {
292 CoinBigIndex start = startColumnU_.array()[maximumColumnsExtra_];
293 CoinBigIndex space = lengthAreaU_ - ( start + numberRowsExtra_ );
294 return (space>=0)&&doForrestTomlin_;
295 }
297
300
302 inline int numberDense() const
303 { return numberDense_;}
304
306 inline CoinBigIndex numberElementsU ( ) const {
307 return lengthU_;
308 }
310 inline void setNumberElementsU(CoinBigIndex value)
311 { lengthU_ = value; }
313 inline CoinBigIndex lengthAreaU ( ) const {
314 return lengthAreaU_;
315 }
317 inline CoinBigIndex numberElementsL ( ) const {
318 return lengthL_;
319 }
321 inline CoinBigIndex lengthAreaL ( ) const {
322 return lengthAreaL_;
323 }
325 inline CoinBigIndex numberElementsR ( ) const {
326 return lengthR_;
327 }
329 inline CoinBigIndex numberCompressions() const
330 { return numberCompressions_;}
332 inline int * numberInRow() const
333 { return numberInRow_.array();}
335 inline int * numberInColumn() const
336 { return numberInColumn_.array();}
338 inline CoinFactorizationDouble * elementU() const
339 { return elementU_.array();}
341 inline int * indexRowU() const
342 { return indexRowU_.array();}
344 inline CoinBigIndex * startColumnU() const
345 { return startColumnU_.array();}
347 inline int maximumColumnsExtra()
348 { return maximumColumnsExtra_;}
352 inline int biasLU() const
353 { return biasLU_;}
354 inline void setBiasLU(int value)
355 { biasLU_=value;}
361 inline int persistenceFlag() const
362 { return persistenceFlag_;}
363 void setPersistenceFlag(int value);
365
368
376 int replaceColumn ( CoinIndexedVector * regionSparse,
377 int pivotRow,
378 double pivotCheck ,
379 bool checkBeforeModifying=false,
380 double acceptablePivot=1.0e-8);
385 void replaceColumnU ( CoinIndexedVector * regionSparse,
386 CoinBigIndex * deleted,
387 int internalPivotRow);
388 #ifdef ABC_USE_COIN_FACTORIZATION
389
391 CoinIndexedVector * fakeVector(CoinIndexedVector * vector,
392 int already=0) const;
393 void deleteFakeVector(CoinIndexedVector * vector,
394 CoinIndexedVector * fakeVector) const;
399 double checkReplacePart1 ( CoinIndexedVector * regionSparse,
400 int pivotRow);
405 double checkReplacePart1 ( CoinIndexedVector * regionSparse,
406 CoinIndexedVector * partialUpdate,
407 int pivotRow);
410 int checkReplacePart2 ( int pivotRow,
411 double btranAlpha,
412 double ftranAlpha,
413 double ftAlpha,
414 double acceptablePivot = 1.0e-8);
417 void replaceColumnPart3 ( CoinIndexedVector * regionSparse,
418 int pivotRow,
419 double alpha );
422 void replaceColumnPart3 ( CoinIndexedVector * regionSparse,
423 CoinIndexedVector * partialUpdate,
424 int pivotRow,
425 double alpha );
433 int updateColumnFT ( CoinIndexedVector & regionSparse);
434 int updateColumnFTPart1 ( CoinIndexedVector & regionSparse) ;
435 void updateColumnFTPart2 ( CoinIndexedVector & regionSparse) ;
439 void updateColumnFT ( CoinIndexedVector & regionSparseFT,
440 CoinIndexedVector & partialUpdate,
441 int which);
443 int updateColumn ( CoinIndexedVector & regionSparse) const;
448 int updateTwoColumnsFT ( CoinIndexedVector & regionSparseFT,
449 CoinIndexedVector & regionSparseOther);
451 int updateColumnTranspose ( CoinIndexedVector & regionSparse) const;
453 void updateColumnCpu ( CoinIndexedVector & regionSparse,int whichCpu) const;
455 void updateColumnTransposeCpu ( CoinIndexedVector & regionSparse,int whichCpu) const;
457 void updateFullColumn ( CoinIndexedVector & regionSparse) const;
459 void updateFullColumnTranspose ( CoinIndexedVector & regionSparse) const;
461 void updateWeights ( CoinIndexedVector & regionSparse) const;
463 inline bool wantsTableauColumn() const
464 {return false;}
466 inline double minimumPivotTolerance ( ) const {
467 return pivotTolerance_ ;
468 }
469 inline void minimumPivotTolerance ( double value )
470 { pivotTolerance(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;}
481 void updatePartialUpdate(CoinIndexedVector & partialUpdate);
483 void makeNonSingular(int * COIN_RESTRICT sequence);
484 #endif
485
486
496 int updateColumnFT ( CoinIndexedVector * regionSparse,
497 CoinIndexedVector * regionSparse2);
500 int updateColumn ( CoinIndexedVector * regionSparse,
501 CoinIndexedVector * regionSparse2,
502 bool noPermute=false) const;
508 int updateTwoColumnsFT ( CoinIndexedVector * regionSparse1,
509 CoinIndexedVector * regionSparse2,
510 CoinIndexedVector * regionSparse3,
511 bool noPermuteRegion3=false) ;
516 int updateColumnTranspose ( CoinIndexedVector * regionSparse,
517 CoinIndexedVector * regionSparse2) const;
519 void goSparse();
521 inline int sparseThreshold ( ) const
522 { return sparseThreshold_;}
524 void sparseThreshold ( int value );
526
531 inline void clearArrays()
533 { gutsOfDestructor();}
535
538
541 int add ( CoinBigIndex numberElements,
542 int indicesRow[],
543 int indicesColumn[], double elements[] );
544
547 int addColumn ( CoinBigIndex numberElements,
548 int indicesRow[], double elements[] );
549
552 int addRow ( CoinBigIndex numberElements,
553 int indicesColumn[], double elements[] );
554
556 int deleteColumn ( int Row );
558 int deleteRow ( int Row );
559
563 int replaceRow ( int whichRow, int numberElements,
564 const int indicesColumn[], const double elements[] );
566 void emptyRows(int numberToEmpty, const int which[]);
568
569 void checkSparse();
572 #if 0 //def CLP_FACTORIZATION_INSTRUMENT
573 inline bool collectStatistics() const
574 { return collectStatistics_;}
576 inline void setCollectStatistics(bool onOff) const
577 { collectStatistics_ = onOff;}
578 #else
579 inline bool collectStatistics() const
580 { return true;}
582 inline void setCollectStatistics(bool onOff) const
583 { }
584 #endif
585 void gutsOfDestructor(int type=1);
588 void gutsOfInitialize(int type);
589 void gutsOfCopy(const CoinFactorization &other);
590
592 void resetStatistics();
593
594
596
598 void getAreas ( int numberRows,
600 int numberColumns,
601 CoinBigIndex maximumL,
602 CoinBigIndex maximumU );
603
606 void preProcess ( int state,
607 int possibleDuplicates = -1 );
609 int factor ( );
610 protected:
613 int factorSparse ( );
616 int factorSparseSmall ( );
619 int factorSparseLarge ( );
622 int factorDense ( );
623
625 bool pivotOneOtherRow ( int pivotRow,
626 int pivotColumn );
628 bool pivotRowSingleton ( int pivotRow,
629 int pivotColumn );
631 bool pivotColumnSingleton ( int pivotRow,
632 int pivotColumn );
633
638 bool getColumnSpace ( int iColumn,
639 int extraNeeded );
640
643 bool reorderU();
647 bool getColumnSpaceIterateR ( int iColumn, double value,
648 int iRow);
654 CoinBigIndex getColumnSpaceIterate ( int iColumn, double value,
655 int iRow);
659 bool getRowSpace ( int iRow, int extraNeeded );
660
664 bool getRowSpaceIterate ( int iRow,
665 int extraNeeded );
667 void checkConsistency ( );
669 inline void addLink ( int index, int count ) {
670 int *nextCount = nextCount_.array();
671 int *firstCount = firstCount_.array();
672 int *lastCount = lastCount_.array();
673 int next = firstCount[count];
674 lastCount[index] = -2 - count;
675 if ( next < 0 ) {
676 //first with that count
677 firstCount[count] = index;
678 nextCount[index] = -1;
679 } else {
680 firstCount[count] = index;
681 nextCount[index] = next;
682 lastCount[next] = index;
683 }}
685 inline void deleteLink ( int index ) {
686 int *nextCount = nextCount_.array();
687 int *firstCount = firstCount_.array();
688 int *lastCount = lastCount_.array();
689 int next = nextCount[index];
690 int last = lastCount[index];
691 if ( last >= 0 ) {
692 nextCount[last] = next;
693 } else {
694 int count = -last - 2;
695
696 firstCount[count] = next;
697 }
698 if ( next >= 0 ) {
699 lastCount[next] = last;
700 }
701 nextCount[index] = -2;
702 lastCount[index] = -2;
703 return;
704 }
706 void separateLinks(int count,bool rowsFirst);
708 void cleanup ( );
709
711 void updateColumnL ( CoinIndexedVector * region, int * indexIn ) const;
713 void updateColumnLDensish ( CoinIndexedVector * region, int * indexIn ) const;
715 void updateColumnLSparse ( CoinIndexedVector * region, int * indexIn ) const;
717 void updateColumnLSparsish ( CoinIndexedVector * region, int * indexIn ) const;
718
720 void updateColumnR ( CoinIndexedVector * region ) const;
723 void updateColumnRFT ( CoinIndexedVector * region, int * indexIn );
724
726 void updateColumnU ( CoinIndexedVector * region, int * indexIn) const;
727
729 void updateColumnUSparse ( CoinIndexedVector * regionSparse,
730 int * indexIn) const;
732 void updateColumnUSparsish ( CoinIndexedVector * regionSparse,
733 int * indexIn) const;
735 int updateColumnUDensish ( double * COIN_RESTRICT region,
736 int * COIN_RESTRICT regionIndex) const;
738 void updateTwoColumnsUDensish (
739 int & numberNonZero1,
740 double * COIN_RESTRICT region1,
741 int * COIN_RESTRICT index1,
742 int & numberNonZero2,
743 double * COIN_RESTRICT region2,
744 int * COIN_RESTRICT index2) const;
746 void updateColumnPFI ( CoinIndexedVector * regionSparse) const;
748 void permuteBack ( CoinIndexedVector * regionSparse,
749 CoinIndexedVector * outVector) const;
750
752 void updateColumnTransposePFI ( CoinIndexedVector * region) const;
755 void updateColumnTransposeU ( CoinIndexedVector * region,
756 int smallestIndex) const;
759 void updateColumnTransposeUSparsish ( CoinIndexedVector * region,
760 int smallestIndex) const;
763 void updateColumnTransposeUDensish ( CoinIndexedVector * region,
764 int smallestIndex) const;
767 void updateColumnTransposeUSparse ( CoinIndexedVector * region) const;
770 void updateColumnTransposeUByColumn ( CoinIndexedVector * region,
771 int smallestIndex) const;
772
774 void updateColumnTransposeR ( CoinIndexedVector * region ) const;
776 void updateColumnTransposeRDensish ( CoinIndexedVector * region ) const;
778 void updateColumnTransposeRSparse ( CoinIndexedVector * region ) const;
779
781 void updateColumnTransposeL ( CoinIndexedVector * region ) const;
783 void updateColumnTransposeLDensish ( CoinIndexedVector * region ) const;
785 void updateColumnTransposeLByRow ( CoinIndexedVector * region ) const;
787 void updateColumnTransposeLSparsish ( CoinIndexedVector * region ) const;
789 void updateColumnTransposeLSparse ( CoinIndexedVector * region ) const;
790 public:
795 int replaceColumnPFI ( CoinIndexedVector * regionSparse,
796 int pivotRow, double alpha);
797 protected:
800 int checkPivot(double saveFromU, double oldPivot) const;
801 /********************************* START LARGE TEMPLATE ********/
802 #ifdef INT_IS_8
803 #define COINFACTORIZATION_BITS_PER_INT 64
804 #define COINFACTORIZATION_SHIFT_PER_INT 6
805 #define COINFACTORIZATION_MASK_PER_INT 0x3f
806 #else
807 #define COINFACTORIZATION_BITS_PER_INT 32
808 #define COINFACTORIZATION_SHIFT_PER_INT 5
809 #define COINFACTORIZATION_MASK_PER_INT 0x1f
810 #endif
811 template <class T> inline bool
812 pivot ( int pivotRow,
813 int pivotColumn,
814 CoinBigIndex pivotRowPosition,
815 CoinBigIndex pivotColumnPosition,
816 CoinFactorizationDouble work[],
817 unsigned int workArea2[],
818 int increment2,
819 T markRow[] ,
820 int largeInteger)
821 {
822 int *indexColumnU = indexColumnU_.array();
823 CoinBigIndex *startColumnU = startColumnU_.array();
824 int *numberInColumn = numberInColumn_.array();
825 CoinFactorizationDouble *elementU = elementU_.array();
826 int *indexRowU = indexRowU_.array();
827 CoinBigIndex *startRowU = startRowU_.array();
828 int *numberInRow = numberInRow_.array();
829 CoinFactorizationDouble *elementL = elementL_.array();
830 int *indexRowL = indexRowL_.array();
831 int *saveColumn = saveColumn_.array();
832 int *nextRow = nextRow_.array();
833 int *lastRow = lastRow_.array() ;
834
835 //store pivot columns (so can easily compress)
836 int numberInPivotRow = numberInRow[pivotRow] - 1;
837 CoinBigIndex startColumn = startColumnU[pivotColumn];
838 int numberInPivotColumn = numberInColumn[pivotColumn] - 1;
839 CoinBigIndex endColumn = startColumn + numberInPivotColumn + 1;
840 int put = 0;
841 CoinBigIndex startRow = startRowU[pivotRow];
842 CoinBigIndex endRow = startRow + numberInPivotRow + 1;
843
844 if ( pivotColumnPosition < 0 ) {
845 for ( pivotColumnPosition = startRow; pivotColumnPosition < endRow; pivotColumnPosition++ ) {
846 int iColumn = indexColumnU[pivotColumnPosition];
847 if ( iColumn != pivotColumn ) {
848 saveColumn[put++] = iColumn;
849 } else {
850 break;
851 }
852 }
853 } else {
854 for (CoinBigIndex i = startRow ; i < pivotColumnPosition ; i++ ) {
855 saveColumn[put++] = indexColumnU[i];
856 }
857 }
858 assert (pivotColumnPosition<endRow);
859 assert (indexColumnU[pivotColumnPosition]==pivotColumn);
860 pivotColumnPosition++;
861 for ( ; pivotColumnPosition < endRow; pivotColumnPosition++ ) {
862 saveColumn[put++] = indexColumnU[pivotColumnPosition];
863 }
864 //take out this bit of indexColumnU
865 int next = nextRow[pivotRow];
866 int last = lastRow[pivotRow];
867
868 nextRow[last] = next;
869 lastRow[next] = last;
870 nextRow[pivotRow] = numberGoodU_; //use for permute
871 lastRow[pivotRow] = -2;
872 numberInRow[pivotRow] = 0;
873 //store column in L, compress in U and take column out
874 CoinBigIndex l = lengthL_;
875
876 if ( l + numberInPivotColumn > lengthAreaL_ ) {
877 //need more memory
878 if ((messageLevel_&4)!=0)
879 printf("more memory needed in middle of invert\n");
880 return false;
881 }
882 //l+=currentAreaL_->elementByColumn-elementL;
883 CoinBigIndex lSave = l;
884
885 CoinBigIndex * startColumnL = startColumnL_.array();
886 startColumnL[numberGoodL_] = l; //for luck and first time
887 numberGoodL_++;
888 startColumnL[numberGoodL_] = l + numberInPivotColumn;
889 lengthL_ += numberInPivotColumn;
890 if ( pivotRowPosition < 0 ) {
891 for ( pivotRowPosition = startColumn; pivotRowPosition < endColumn; pivotRowPosition++ ) {
892 int iRow = indexRowU[pivotRowPosition];
893 if ( iRow != pivotRow ) {
894 indexRowL[l] = iRow;
895 elementL[l] = elementU[pivotRowPosition];
896 markRow[iRow] = static_cast<T>(l - lSave);
897 l++;
898 //take out of row list
899 CoinBigIndex start = startRowU[iRow];
900 CoinBigIndex end = start + numberInRow[iRow];
901 CoinBigIndex where = start;
902
903 while ( indexColumnU[where] != pivotColumn ) {
904 where++;
905 } /* endwhile */
906 #if DEBUG_COIN
907 if ( where >= end ) {
908 abort ( );
909 }
910 #endif
911 indexColumnU[where] = indexColumnU[end - 1];
912 numberInRow[iRow]--;
913 } else {
914 break;
915 }
916 }
917 } else {
918 CoinBigIndex i;
919
920 for ( i = startColumn; i < pivotRowPosition; i++ ) {
921 int iRow = indexRowU[i];
922
923 markRow[iRow] = static_cast<T>(l - lSave);
924 indexRowL[l] = iRow;
925 elementL[l] = elementU[i];
926 l++;
927 //take out of row list
928 CoinBigIndex start = startRowU[iRow];
929 CoinBigIndex end = start + numberInRow[iRow];
930 CoinBigIndex where = start;
931
932 while ( indexColumnU[where] != pivotColumn ) {
933 where++;
934 } /* endwhile */
935 #if DEBUG_COIN
936 if ( where >= end ) {
937 abort ( );
938 }
939 #endif
940 indexColumnU[where] = indexColumnU[end - 1];
941 numberInRow[iRow]--;
942 assert (numberInRow[iRow]>=0);
943 }
944 }
945 assert (pivotRowPosition<endColumn);
946 assert (indexRowU[pivotRowPosition]==pivotRow);
947 CoinFactorizationDouble pivotElement = elementU[pivotRowPosition];
948 CoinFactorizationDouble pivotMultiplier = 1.0 / pivotElement;
949
950 pivotRegion_.array()[numberGoodU_] = pivotMultiplier;
951 pivotRowPosition++;
952 for ( ; pivotRowPosition < endColumn; pivotRowPosition++ ) {
953 int iRow = indexRowU[pivotRowPosition];
954
955 markRow[iRow] = static_cast<T>(l - lSave);
956 indexRowL[l] = iRow;
957 elementL[l] = elementU[pivotRowPosition];
958 l++;
959 //take out of row list
960 CoinBigIndex start = startRowU[iRow];
961 CoinBigIndex end = start + numberInRow[iRow];
962 CoinBigIndex where = start;
963
964 while ( indexColumnU[where] != pivotColumn ) {
965 where++;
966 } /* endwhile */
967 #if DEBUG_COIN
968 if ( where >= end ) {
969 abort ( );
970 }
971 #endif
972 indexColumnU[where] = indexColumnU[end - 1];
973 numberInRow[iRow]--;
974 assert (numberInRow[iRow]>=0);
975 }
976 markRow[pivotRow] = static_cast<T>(largeInteger);
977 //compress pivot column (move pivot to front including saved)
978 numberInColumn[pivotColumn] = 0;
979 //use end of L for temporary space
980 int *indexL = &indexRowL[lSave];
981 CoinFactorizationDouble *multipliersL = &elementL[lSave];
982
983 //adjust
984 int j;
985
986 for ( j = 0; j < numberInPivotColumn; j++ ) {
987 multipliersL[j] *= pivotMultiplier;
988 }
989 //zero out fill
990 CoinBigIndex iErase;
991 for ( iErase = 0; iErase < increment2 * numberInPivotRow;
992 iErase++ ) {
993 workArea2[iErase] = 0;
994 }
995 CoinBigIndex added = numberInPivotRow * numberInPivotColumn;
996 unsigned int *temp2 = workArea2;
997 int * nextColumn = nextColumn_.array();
998
999 //pack down and move to work
1000 int jColumn;
1001 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1002 int iColumn = saveColumn[jColumn];
1003 CoinBigIndex startColumn = startColumnU[iColumn];
1004 CoinBigIndex endColumn = startColumn + numberInColumn[iColumn];
1005 int iRow = indexRowU[startColumn];
1006 CoinFactorizationDouble value = elementU[startColumn];
1007 double largest;
1008 CoinBigIndex put = startColumn;
1009 CoinBigIndex positionLargest = -1;
1010 CoinFactorizationDouble thisPivotValue = 0.0;
1011
1012 //compress column and find largest not updated
1013 bool checkLargest;
1014 int mark = markRow[iRow];
1015
1016 if ( mark == largeInteger+1 ) {
1017 largest = fabs ( value );
1018 positionLargest = put;
1019 put++;
1020 checkLargest = false;
1021 } else {
1022 //need to find largest
1023 largest = 0.0;
1024 checkLargest = true;
1025 if ( mark != largeInteger ) {
1026 //will be updated
1027 work[mark] = value;
1028 int word = mark >> COINFACTORIZATION_SHIFT_PER_INT;
1029 int bit = mark & COINFACTORIZATION_MASK_PER_INT;
1030
1031 temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts
1032 added--;
1033 } else {
1034 thisPivotValue = value;
1035 }
1036 }
1037 CoinBigIndex i;
1038 for ( i = startColumn + 1; i < endColumn; i++ ) {
1039 iRow = indexRowU[i];
1040 value = elementU[i];
1041 int mark = markRow[iRow];
1042
1043 if ( mark == largeInteger+1 ) {
1044 //keep
1045 indexRowU[put] = iRow;
1046 elementU[put] = value;
1047 if ( checkLargest ) {
1048 double absValue = fabs ( value );
1049
1050 if ( absValue > largest ) {
1051 largest = absValue;
1052 positionLargest = put;
1053 }
1054 }
1055 put++;
1056 } else if ( mark != largeInteger ) {
1057 //will be updated
1058 work[mark] = value;
1059 int word = mark >> COINFACTORIZATION_SHIFT_PER_INT;
1060 int bit = mark & COINFACTORIZATION_MASK_PER_INT;
1061
1062 temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts
1063 added--;
1064 } else {
1065 thisPivotValue = value;
1066 }
1067 }
1068 //slot in pivot
1069 elementU[put] = elementU[startColumn];
1070 indexRowU[put] = indexRowU[startColumn];
1071 if ( positionLargest == startColumn ) {
1072 positionLargest = put; //follow if was largest
1073 }
1074 put++;
1075 elementU[startColumn] = thisPivotValue;
1076 indexRowU[startColumn] = pivotRow;
1077 //clean up counts
1078 startColumn++;
1079 numberInColumn[iColumn] = put - startColumn;
1080 int * numberInColumnPlus = numberInColumnPlus_.array();
1081 numberInColumnPlus[iColumn]++;
1082 startColumnU[iColumn]++;
1083 //how much space have we got
1084 int next = nextColumn[iColumn];
1085 CoinBigIndex space;
1086
1087 space = startColumnU[next] - put - numberInColumnPlus[next];
1088 //assume no zero elements
1089 if ( numberInPivotColumn > space ) {
1090 //getColumnSpace also moves fixed part
1091 if ( !getColumnSpace ( iColumn, numberInPivotColumn ) ) {
1092 return false;
1093 }
1094 //redo starts
1095 if (positionLargest >= 0)
1096 positionLargest = positionLargest + startColumnU[iColumn] - startColumn;
1097 startColumn = startColumnU[iColumn];
1098 put = startColumn + numberInColumn[iColumn];
1099 }
1100 double tolerance = zeroTolerance_;
1101
1102 int *nextCount = nextCount_.array();
1103 for ( j = 0; j < numberInPivotColumn; j++ ) {
1104 value = work[j] - thisPivotValue * multipliersL[j];
1105 double absValue = fabs ( value );
1106
1107 if ( absValue > tolerance ) {
1108 work[j] = 0.0;
1109 assert (put<lengthAreaU_);
1110 elementU[put] = value;
1111 indexRowU[put] = indexL[j];
1112 if ( absValue > largest ) {
1113 largest = absValue;
1114 positionLargest = put;
1115 }
1116 put++;
1117 } else {
1118 work[j] = 0.0;
1119 added--;
1120 int word = j >> COINFACTORIZATION_SHIFT_PER_INT;
1121 int bit = j & COINFACTORIZATION_MASK_PER_INT;
1122
1123 if ( temp2[word] & ( 1 << bit ) ) {
1124 //take out of row list
1125 iRow = indexL[j];
1126 CoinBigIndex start = startRowU[iRow];
1127 CoinBigIndex end = start + numberInRow[iRow];
1128 CoinBigIndex where = start;
1129
1130 while ( indexColumnU[where] != iColumn ) {
1131 where++;
1132 } /* endwhile */
1133 #if DEBUG_COIN
1134 if ( where >= end ) {
1135 abort ( );
1136 }
1137 #endif
1138 indexColumnU[where] = indexColumnU[end - 1];
1139 numberInRow[iRow]--;
1140 } else {
1141 //make sure won't be added
1142 int word = j >> COINFACTORIZATION_SHIFT_PER_INT;
1143 int bit = j & COINFACTORIZATION_MASK_PER_INT;
1144
1145 temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts
1146 }
1147 }
1148 }
1149 numberInColumn[iColumn] = put - startColumn;
1150 //move largest
1151 if ( positionLargest >= 0 ) {
1152 value = elementU[positionLargest];
1153 iRow = indexRowU[positionLargest];
1154 elementU[positionLargest] = elementU[startColumn];
1155 indexRowU[positionLargest] = indexRowU[startColumn];
1156 elementU[startColumn] = value;
1157 indexRowU[startColumn] = iRow;
1158 }
1159 //linked list for column
1160 if ( nextCount[iColumn + numberRows_] != -2 ) {
1161 //modify linked list
1162 deleteLink ( iColumn + numberRows_ );
1163 addLink ( iColumn + numberRows_, numberInColumn[iColumn] );
1164 }
1165 temp2 += increment2;
1166 }
1167 //get space for row list
1168 unsigned int *putBase = workArea2;
1169 int bigLoops = numberInPivotColumn >> COINFACTORIZATION_SHIFT_PER_INT;
1170 int i = 0;
1171
1172 // do linked lists and update counts
1173 while ( bigLoops ) {
1174 bigLoops--;
1175 int bit;
1176 for ( bit = 0; bit < COINFACTORIZATION_BITS_PER_INT; i++, bit++ ) {
1177 unsigned int *putThis = putBase;
1178 int iRow = indexL[i];
1179
1180 //get space
1181 int number = 0;
1182 int jColumn;
1183
1184 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1185 unsigned int test = *putThis;
1186
1187 putThis += increment2;
1188 test = 1 - ( ( test >> bit ) & 1 );
1189 number += test;
1190 }
1191 int next = nextRow[iRow];
1192 CoinBigIndex space;
1193
1194 space = startRowU[next] - startRowU[iRow];
1195 number += numberInRow[iRow];
1196 if ( space < number ) {
1197 if ( !getRowSpace ( iRow, number ) ) {
1198 return false;
1199 }
1200 }
1201 // now do
1202 putThis = putBase;
1203 next = nextRow[iRow];
1204 number = numberInRow[iRow];
1205 CoinBigIndex end = startRowU[iRow] + number;
1206 int saveIndex = indexColumnU[startRowU[next]];
1207
1208 //add in
1209 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1210 unsigned int test = *putThis;
1211
1212 putThis += increment2;
1213 test = 1 - ( ( test >> bit ) & 1 );
1214 indexColumnU[end] = saveColumn[jColumn];
1215 end += test;
1216 }
1217 //put back next one in case zapped
1218 indexColumnU[startRowU[next]] = saveIndex;
1219 markRow[iRow] = static_cast<T>(largeInteger+1);
1220 number = end - startRowU[iRow];
1221 numberInRow[iRow] = number;
1222 deleteLink ( iRow );
1223 addLink ( iRow, number );
1224 }
1225 putBase++;
1226 } /* endwhile */
1227 int bit;
1228
1229 for ( bit = 0; i < numberInPivotColumn; i++, bit++ ) {
1230 unsigned int *putThis = putBase;
1231 int iRow = indexL[i];
1232
1233 //get space
1234 int number = 0;
1235 int jColumn;
1236
1237 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1238 unsigned int test = *putThis;
1239
1240 putThis += increment2;
1241 test = 1 - ( ( test >> bit ) & 1 );
1242 number += test;
1243 }
1244 int next = nextRow[iRow];
1245 CoinBigIndex space;
1246
1247 space = startRowU[next] - startRowU[iRow];
1248 number += numberInRow[iRow];
1249 if ( space < number ) {
1250 if ( !getRowSpace ( iRow, number ) ) {
1251 return false;
1252 }
1253 }
1254 // now do
1255 putThis = putBase;
1256 next = nextRow[iRow];
1257 number = numberInRow[iRow];
1258 CoinBigIndex end = startRowU[iRow] + number;
1259 int saveIndex;
1260
1261 saveIndex = indexColumnU[startRowU[next]];
1262
1263 //add in
1264 for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
1265 unsigned int test = *putThis;
1266
1267 putThis += increment2;
1268 test = 1 - ( ( test >> bit ) & 1 );
1269
1270 indexColumnU[end] = saveColumn[jColumn];
1271 end += test;
1272 }
1273 indexColumnU[startRowU[next]] = saveIndex;
1274 markRow[iRow] = static_cast<T>(largeInteger+1);
1275 number = end - startRowU[iRow];
1276 numberInRow[iRow] = number;
1277 deleteLink ( iRow );
1278 addLink ( iRow, number );
1279 }
1280 markRow[pivotRow] = static_cast<T>(largeInteger+1);
1281 //modify linked list for pivots
1282 deleteLink ( pivotRow );
1283 deleteLink ( pivotColumn + numberRows_ );
1284 totalElements_ += added;
1285 return true;
1286 }
1287
1288 /********************************* END LARGE TEMPLATE ********/
1290 protected:
1292
1295 double pivotTolerance_;
1298 double zeroTolerance_;
1299 #ifndef COIN_FAST_CODE
1300 double slackValue_;
1302 #else
1303 #ifndef slackValue_
1304 #define slackValue_ -1.0
1305 #endif
1306 #endif
1307 double areaFactor_;
1310 double relaxCheck_;
1312 int numberRows_;
1314 int numberRowsExtra_;
1316 int maximumRowsExtra_;
1318 int numberColumns_;
1320 int numberColumnsExtra_;
1322 int maximumColumnsExtra_;
1324 int numberGoodU_;
1326 int numberGoodL_;
1328 int maximumPivots_;
1330 int numberPivots_;
1333 CoinBigIndex totalElements_;
1335 CoinBigIndex factorElements_;
1337 CoinIntArrayWithLength pivotColumn_;
1339 CoinIntArrayWithLength permute_;
1341 CoinIntArrayWithLength permuteBack_;
1343 CoinIntArrayWithLength pivotColumnBack_;
1345 int status_;
1346
1351 //int increasingRows_;
1352
1354 int numberTrials_;
1356 CoinBigIndexArrayWithLength startRowU_;
1357
1359 CoinIntArrayWithLength numberInRow_;
1360
1362 CoinIntArrayWithLength numberInColumn_;
1363
1365 CoinIntArrayWithLength numberInColumnPlus_;
1366
1369 CoinIntArrayWithLength firstCount_;
1370
1372 CoinIntArrayWithLength nextCount_;
1373
1375 CoinIntArrayWithLength lastCount_;
1376
1378 CoinIntArrayWithLength nextColumn_;
1379
1381 CoinIntArrayWithLength lastColumn_;
1382
1384 CoinIntArrayWithLength nextRow_;
1385
1387 CoinIntArrayWithLength lastRow_;
1388
1390 CoinIntArrayWithLength saveColumn_;
1391
1393 CoinIntArrayWithLength markRow_;
1394
1396 int messageLevel_;
1397
1399 int biggerDimension_;
1400
1402 CoinIntArrayWithLength indexColumnU_;
1403
1405 CoinIntArrayWithLength pivotRowL_;
1406
1408 CoinFactorizationDoubleArrayWithLength pivotRegion_;
1409
1411 int numberSlacks_;
1412
1414 int numberU_;
1415
1417 CoinBigIndex maximumU_;
1418
1420 //int baseU_;
1421
1423 CoinBigIndex lengthU_;
1424
1426 CoinBigIndex lengthAreaU_;
1427
1429 CoinFactorizationDoubleArrayWithLength elementU_;
1430
1432 CoinIntArrayWithLength indexRowU_;
1433
1435 CoinBigIndexArrayWithLength startColumnU_;
1436
1438 CoinBigIndexArrayWithLength convertRowToColumnU_;
1439
1441 CoinBigIndex numberL_;
1442
1444 CoinBigIndex baseL_;
1445
1447 CoinBigIndex lengthL_;
1448
1450 CoinBigIndex lengthAreaL_;
1451
1453 CoinFactorizationDoubleArrayWithLength elementL_;
1454
1456 CoinIntArrayWithLength indexRowL_;
1457
1459 CoinBigIndexArrayWithLength startColumnL_;
1460
1462 bool doForrestTomlin_;
1463
1465 int numberR_;
1466
1468 CoinBigIndex lengthR_;
1469
1471 CoinBigIndex lengthAreaR_;
1472
1474 CoinFactorizationDouble *elementR_;
1475
1477 int *indexRowR_;
1478
1480 CoinBigIndexArrayWithLength startColumnR_;
1481
1483 double * denseArea_;
1484
1486 double * denseAreaAddress_;
1487
1489 int * densePermute_;
1490
1492 int numberDense_;
1493
1495 int denseThreshold_;
1496
1498 CoinFactorizationDoubleArrayWithLength workArea_;
1499
1501 CoinUnsignedIntArrayWithLength workArea2_;
1502
1504 CoinBigIndex numberCompressions_;
1505
1506 public:
1508 mutable double ftranCountInput_;
1509 mutable double ftranCountAfterL_;
1510 mutable double ftranCountAfterR_;
1511 mutable double ftranCountAfterU_;
1512 mutable double btranCountInput_;
1513 mutable double btranCountAfterU_;
1514 mutable double btranCountAfterR_;
1515 mutable double btranCountAfterL_;
1516
1518 mutable int numberFtranCounts_;
1519 mutable int numberBtranCounts_;
1520
1522 double ftranAverageAfterL_;
1523 double ftranAverageAfterR_;
1524 double ftranAverageAfterU_;
1525 double btranAverageAfterU_;
1526 double btranAverageAfterR_;
1527 double btranAverageAfterL_;
1528 protected:
1529
1531 #if 0
1532 mutable bool collectStatistics_;
1533 #else
1534 #define collectStatistics_ 1
1535 #endif
1536
1538 int sparseThreshold_;
1539
1541 int sparseThreshold2_;
1542
1544 CoinBigIndexArrayWithLength startRowL_;
1545
1547 CoinIntArrayWithLength indexColumnL_;
1548
1550 CoinFactorizationDoubleArrayWithLength elementByRowL_;
1551
1553 mutable CoinIntArrayWithLength sparse_;
1557 int biasLU_;
1563 int persistenceFlag_;
1564 #ifdef ABC_USE_COIN_FACTORIZATION
1565 int parallelMode_;
1567 #endif
1568
1569 };
1570 // Dense coding
1571 #ifdef COIN_HAS_LAPACK
1572 #ifndef COIN_FACTORIZATION_DENSE_CODE
1573 #define COIN_FACTORIZATION_DENSE_CODE 1
1574 #endif
1575 #endif
1576 #ifdef COIN_FACTORIZATION_DENSE_CODE
1577 /* Type of Fortran integer translated into C */
1578 #ifndef ipfint
1579 //typedef ipfint FORTRAN_INTEGER_TYPE ;
1580 typedef int ipfint;
1581 typedef const int cipfint;
1582 #endif
1583 #endif
1584 #endif
1585 // Extra for ugly include
1586 #ifdef UGLY_COIN_FACTOR_CODING
1587 #define FAC_UNSET (FAC_SET+1)
1588 {
1589 goodPivot=false;
1590 //store pivot columns (so can easily compress)
1591 CoinBigIndex startColumnThis = startColumn[iPivotColumn];
1592 CoinBigIndex endColumn = startColumnThis + numberDoColumn + 1;
1593 int put = 0;
1594 CoinBigIndex startRowThis = startRow[iPivotRow];
1595 CoinBigIndex endRow = startRowThis + numberDoRow + 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;
1601 } else {
1602 break;
1603 }
1604 }
1605 } else {
1606 for (CoinBigIndex i = startRowThis ; i < pivotColumnPosition ; i++ ) {
1607 saveColumn[put++] = indexColumn[i];
1608 }
1609 }
1610 assert (pivotColumnPosition<endRow);
1611 assert (indexColumn[pivotColumnPosition]==iPivotColumn);
1612 pivotColumnPosition++;
1613 for ( ; pivotColumnPosition < endRow; pivotColumnPosition++ ) {
1614 saveColumn[put++] = indexColumn[pivotColumnPosition];
1615 }
1616 //take out this bit of indexColumn
1617 int next = nextRow[iPivotRow];
1618 int last = lastRow[iPivotRow];
1619
1620 nextRow[last] = next;
1621 lastRow[next] = last;
1622 nextRow[iPivotRow] = numberGoodU_; //use for permute
1623 lastRow[iPivotRow] = -2;
1624 numberInRow[iPivotRow] = 0;
1625 //store column in L, compress in U and take column out
1626 CoinBigIndex l = lengthL_;
1627 // **** HORRID coding coming up but a goto seems best!
1628 {
1629 if ( l + numberDoColumn > lengthAreaL_ ) {
1630 //need more memory
1631 if ((messageLevel_&4)!=0)
1632 printf("more memory needed in middle of invert\n");
1633 goto BAD_PIVOT;
1634 }
1635 //l+=currentAreaL_->elementByColumn-elementL;
1636 CoinBigIndex lSave = l;
1637
1638 CoinBigIndex * startColumnL = startColumnL_.array();
1639 startColumnL[numberGoodL_] = l; //for luck and first time
1640 numberGoodL_++;
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;
1650 l++;
1651 //take out of row list
1652 CoinBigIndex start = startRow[iRow];
1653 CoinBigIndex end = start + numberInRow[iRow];
1654 CoinBigIndex where = start;
1655
1656 while ( indexColumn[where] != iPivotColumn ) {
1657 where++;
1658 } /* endwhile */
1659 #if DEBUG_COIN
1660 if ( where >= end ) {
1661 abort ( );
1662 }
1663 #endif
1664 indexColumn[where] = indexColumn[end - 1];
1665 numberInRow[iRow]--;
1666 } else {
1667 break;
1668 }
1669 }
1670 } else {
1671 CoinBigIndex i;
1672
1673 for ( i = startColumnThis; i < pivotRowPosition; i++ ) {
1674 int iRow = indexRow[i];
1675
1676 markRow[iRow] = l - lSave;
1677 indexRowL[l] = iRow;
1678 elementL[l] = element[i];
1679 l++;
1680 //take out of row list
1681 CoinBigIndex start = startRow[iRow];
1682 CoinBigIndex end = start + numberInRow[iRow];
1683 CoinBigIndex where = start;
1684
1685 while ( indexColumn[where] != iPivotColumn ) {
1686 where++;
1687 } /* endwhile */
1688 #if DEBUG_COIN
1689 if ( where >= end ) {
1690 abort ( );
1691 }
1692 #endif
1693 indexColumn[where] = indexColumn[end - 1];
1694 numberInRow[iRow]--;
1695 assert (numberInRow[iRow]>=0);
1696 }
1697 }
1698 assert (pivotRowPosition<endColumn);
1699 assert (indexRow[pivotRowPosition]==iPivotRow);
1700 CoinFactorizationDouble pivotElement = element[pivotRowPosition];
1701 CoinFactorizationDouble pivotMultiplier = 1.0 / pivotElement;
1702
1703 pivotRegion_.array()[numberGoodU_] = pivotMultiplier;
1704 pivotRowPosition++;
1705 for ( ; pivotRowPosition < endColumn; pivotRowPosition++ ) {
1706 int iRow = indexRow[pivotRowPosition];
1707
1708 markRow[iRow] = l - lSave;
1709 indexRowL[l] = iRow;
1710 elementL[l] = element[pivotRowPosition];
1711 l++;
1712 //take out of row list
1713 CoinBigIndex start = startRow[iRow];
1714 CoinBigIndex end = start + numberInRow[iRow];
1715 CoinBigIndex where = start;
1716
1717 while ( indexColumn[where] != iPivotColumn ) {
1718 where++;
1719 } /* endwhile */
1720 #if DEBUG_COIN
1721 if ( where >= end ) {
1722 abort ( );
1723 }
1724 #endif
1725 indexColumn[where] = indexColumn[end - 1];
1726 numberInRow[iRow]--;
1727 assert (numberInRow[iRow]>=0);
1728 }
1729 markRow[iPivotRow] = FAC_SET;
1730 //compress pivot column (move pivot to front including saved)
1731 numberInColumn[iPivotColumn] = 0;
1732 //use end of L for temporary space
1733 int *indexL = &indexRowL[lSave];
1734 CoinFactorizationDouble *multipliersL = &elementL[lSave];
1735
1736 //adjust
1737 int j;
1738
1739 for ( j = 0; j < numberDoColumn; j++ ) {
1740 multipliersL[j] *= pivotMultiplier;
1741 }
1742 //zero out fill
1743 CoinBigIndex iErase;
1744 for ( iErase = 0; iErase < increment2 * numberDoRow;
1745 iErase++ ) {
1746 workArea2[iErase] = 0;
1747 }
1748 CoinBigIndex added = numberDoRow * numberDoColumn;
1749 unsigned int *temp2 = workArea2;
1750 int * nextColumn = nextColumn_.array();
1751
1752 //pack down and move to work
1753 int jColumn;
1754 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
1755 int iColumn = saveColumn[jColumn];
1756 CoinBigIndex startColumnThis = startColumn[iColumn];
1757 CoinBigIndex endColumn = startColumnThis + numberInColumn[iColumn];
1758 int iRow = indexRow[startColumnThis];
1759 CoinFactorizationDouble value = element[startColumnThis];
1760 double largest;
1761 CoinBigIndex put = startColumnThis;
1762 CoinBigIndex positionLargest = -1;
1763 CoinFactorizationDouble thisPivotValue = 0.0;
1764
1765 //compress column and find largest not updated
1766 bool checkLargest;
1767 int mark = markRow[iRow];
1768
1769 if ( mark == FAC_UNSET ) {
1770 largest = fabs ( value );
1771 positionLargest = put;
1772 put++;
1773 checkLargest = false;
1774 } else {
1775 //need to find largest
1776 largest = 0.0;
1777 checkLargest = true;
1778 if ( mark != FAC_SET ) {
1779 //will be updated
1780 workArea[mark] = value;
1781 int word = mark >> COINFACTORIZATION_SHIFT_PER_INT;
1782 int bit = mark & COINFACTORIZATION_MASK_PER_INT;
1783
1784 temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts
1785 added--;
1786 } else {
1787 thisPivotValue = value;
1788 }
1789 }
1790 CoinBigIndex i;
1791 for ( i = startColumnThis + 1; i < endColumn; i++ ) {
1792 iRow = indexRow[i];
1793 value = element[i];
1794 int mark = markRow[iRow];
1795
1796 if ( mark == FAC_UNSET ) {
1797 //keep
1798 indexRow[put] = iRow;
1799 element[put] = value;
1800 if ( checkLargest ) {
1801 double absValue = fabs ( value );
1802
1803 if ( absValue > largest ) {
1804 largest = absValue;
1805 positionLargest = put;
1806 }
1807 }
1808 put++;
1809 } else if ( mark != FAC_SET ) {
1810 //will be updated
1811 workArea[mark] = value;
1812 int word = mark >> COINFACTORIZATION_SHIFT_PER_INT;
1813 int bit = mark & COINFACTORIZATION_MASK_PER_INT;
1814
1815 temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts
1816 added--;
1817 } else {
1818 thisPivotValue = value;
1819 }
1820 }
1821 //slot in pivot
1822 element[put] = element[startColumnThis];
1823 indexRow[put] = indexRow[startColumnThis];
1824 if ( positionLargest == startColumnThis ) {
1825 positionLargest = put; //follow if was largest
1826 }
1827 put++;
1828 element[startColumnThis] = thisPivotValue;
1829 indexRow[startColumnThis] = iPivotRow;
1830 //clean up counts
1831 startColumnThis++;
1832 numberInColumn[iColumn] = put - startColumnThis;
1833 int * numberInColumnPlus = numberInColumnPlus_.array();
1834 numberInColumnPlus[iColumn]++;
1835 startColumn[iColumn]++;
1836 //how much space have we got
1837 int next = nextColumn[iColumn];
1838 CoinBigIndex space;
1839
1840 space = startColumn[next] - put - numberInColumnPlus[next];
1841 //assume no zero elements
1842 if ( numberDoColumn > space ) {
1843 //getColumnSpace also moves fixed part
1844 if ( !getColumnSpace ( iColumn, numberDoColumn ) ) {
1845 goto BAD_PIVOT;
1846 }
1847 //redo starts
1848 positionLargest = positionLargest + startColumn[iColumn] - startColumnThis;
1849 startColumnThis = startColumn[iColumn];
1850 put = startColumnThis + numberInColumn[iColumn];
1851 }
1852 double tolerance = zeroTolerance_;
1853
1854 int *nextCount = nextCount_.array();
1855 for ( j = 0; j < numberDoColumn; j++ ) {
1856 value = workArea[j] - thisPivotValue * multipliersL[j];
1857 double absValue = fabs ( value );
1858
1859 if ( absValue > tolerance ) {
1860 workArea[j] = 0.0;
1861 element[put] = value;
1862 indexRow[put] = indexL[j];
1863 if ( absValue > largest ) {
1864 largest = absValue;
1865 positionLargest = put;
1866 }
1867 put++;
1868 } else {
1869 workArea[j] = 0.0;
1870 added--;
1871 int word = j >> COINFACTORIZATION_SHIFT_PER_INT;
1872 int bit = j & COINFACTORIZATION_MASK_PER_INT;
1873
1874 if ( temp2[word] & ( 1 << bit ) ) {
1875 //take out of row list
1876 iRow = indexL[j];
1877 CoinBigIndex start = startRow[iRow];
1878 CoinBigIndex end = start + numberInRow[iRow];
1879 CoinBigIndex where = start;
1880
1881 while ( indexColumn[where] != iColumn ) {
1882 where++;
1883 } /* endwhile */
1884 #if DEBUG_COIN
1885 if ( where >= end ) {
1886 abort ( );
1887 }
1888 #endif
1889 indexColumn[where] = indexColumn[end - 1];
1890 numberInRow[iRow]--;
1891 } else {
1892 //make sure won't be added
1893 int word = j >> COINFACTORIZATION_SHIFT_PER_INT;
1894 int bit = j & COINFACTORIZATION_MASK_PER_INT;
1895
1896 temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts
1897 }
1898 }
1899 }
1900 numberInColumn[iColumn] = put - startColumnThis;
1901 //move largest
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;
1909 }
1910 //linked list for column
1911 if ( nextCount[iColumn + numberRows_] != -2 ) {
1912 //modify linked list
1913 deleteLink ( iColumn + numberRows_ );
1914 addLink ( iColumn + numberRows_, numberInColumn[iColumn] );
1915 }
1916 temp2 += increment2;
1917 }
1918 //get space for row list
1919 unsigned int *putBase = workArea2;
1920 int bigLoops = numberDoColumn >> COINFACTORIZATION_SHIFT_PER_INT;
1921 int i = 0;
1922
1923 // do linked lists and update counts
1924 while ( bigLoops ) {
1925 bigLoops--;
1926 int bit;
1927 for ( bit = 0; bit < COINFACTORIZATION_BITS_PER_INT; i++, bit++ ) {
1928 unsigned int *putThis = putBase;
1929 int iRow = indexL[i];
1930
1931 //get space
1932 int number = 0;
1933 int jColumn;
1934
1935 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
1936 unsigned int test = *putThis;
1937
1938 putThis += increment2;
1939 test = 1 - ( ( test >> bit ) & 1 );
1940 number += test;
1941 }
1942 int next = nextRow[iRow];
1943 CoinBigIndex space;
1944
1945 space = startRow[next] - startRow[iRow];
1946 number += numberInRow[iRow];
1947 if ( space < number ) {
1948 if ( !getRowSpace ( iRow, number ) ) {
1949 goto BAD_PIVOT;
1950 }
1951 }
1952 // now do
1953 putThis = putBase;
1954 next = nextRow[iRow];
1955 number = numberInRow[iRow];
1956 CoinBigIndex end = startRow[iRow] + number;
1957 int saveIndex = indexColumn[startRow[next]];
1958
1959 //add in
1960 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
1961 unsigned int test = *putThis;
1962
1963 putThis += increment2;
1964 test = 1 - ( ( test >> bit ) & 1 );
1965 indexColumn[end] = saveColumn[jColumn];
1966 end += test;
1967 }
1968 //put back next one in case zapped
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 );
1975 }
1976 putBase++;
1977 } /* endwhile */
1978 int bit;
1979
1980 for ( bit = 0; i < numberDoColumn; i++, bit++ ) {
1981 unsigned int *putThis = putBase;
1982 int iRow = indexL[i];
1983
1984 //get space
1985 int number = 0;
1986 int jColumn;
1987
1988 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
1989 unsigned int test = *putThis;
1990
1991 putThis += increment2;
1992 test = 1 - ( ( test >> bit ) & 1 );
1993 number += test;
1994 }
1995 int next = nextRow[iRow];
1996 CoinBigIndex space;
1997
1998 space = startRow[next] - startRow[iRow];
1999 number += numberInRow[iRow];
2000 if ( space < number ) {
2001 if ( !getRowSpace ( iRow, number ) ) {
2002 goto BAD_PIVOT;
2003 }
2004 }
2005 // now do
2006 putThis = putBase;
2007 next = nextRow[iRow];
2008 number = numberInRow[iRow];
2009 CoinBigIndex end = startRow[iRow] + number;
2010 int saveIndex;
2011
2012 saveIndex = indexColumn[startRow[next]];
2013
2014 //add in
2015 for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) {
2016 unsigned int test = *putThis;
2017
2018 putThis += increment2;
2019 test = 1 - ( ( test >> bit ) & 1 );
2020
2021 indexColumn[end] = saveColumn[jColumn];
2022 end += test;
2023 }
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 );
2030 }
2031 markRow[iPivotRow] = FAC_UNSET;
2032 //modify linked list for pivots
2033 deleteLink ( iPivotRow );
2034 deleteLink ( iPivotColumn + numberRows_ );
2035 totalElements_ += added;
2036 goodPivot= true;
2037 // **** UGLY UGLY UGLY
2038 }
2039 BAD_PIVOT:
2040
2041 ;
2042 }
2043 #undef FAC_UNSET
2044 #endif
CoinFactorization::ftranCountAfterR_
double ftranCountAfterR_
Definition: CoinFactorization.hpp:1510
CoinBigIndexArrayWithLength::array
CoinBigIndex * array() const
Get Array.
Definition: CoinIndexedVector.hpp:844
CoinFactorization::startRowU_
CoinBigIndexArrayWithLength startRowU_
Start of each Row as pointer.
Definition: CoinFactorization.hpp:1356
CoinFactorization::numberL_
CoinBigIndex numberL_
Number in L.
Definition: CoinFactorization.hpp:1441
CoinFactorization::numberR_
int numberR_
Number in R.
Definition: CoinFactorization.hpp:1465
CoinFactorization::factorElements_
CoinBigIndex factorElements_
Number of elements after factorization.
Definition: CoinFactorization.hpp:1335
CoinUnsignedIntArrayWithLength
unsigned int * version
Definition: CoinIndexedVector.hpp:889
COINFACTORIZATION_BITS_PER_INT
#define COINFACTORIZATION_BITS_PER_INT
Definition: CoinFactorization.hpp:807
CoinFactorization::elementU
CoinFactorizationDouble * elementU() const
Elements of U.
Definition: CoinFactorization.hpp:338
CoinFactorization::getColumnSpaceIterateR
bool getColumnSpaceIterateR(int iColumn, double value, int iRow)
getColumnSpaceIterateR.
CoinFactorization::nextColumn_
CoinIntArrayWithLength nextColumn_
Next Column in memory order.
Definition: CoinFactorization.hpp:1378
CoinFactorization::pivotOneOtherRow
bool pivotOneOtherRow(int pivotRow, int pivotColumn)
Pivots when just one other row so faster?
CoinFactorization::startRowL
CoinBigIndex * startRowL() const
Start of each row in L.
Definition: CoinFactorization.hpp:177
CoinFactorization::pivotRegion_
CoinFactorizationDoubleArrayWithLength pivotRegion_
Inverses of pivot values.
Definition: CoinFactorization.hpp:1408
CoinFactorization::setPivots
void setPivots(int value)
Sets number of pivots since factorization.
Definition: CoinFactorization.hpp:148
CoinFactorization::separateLinks
void separateLinks(int count, bool rowsFirst)
Separate out links with same row/column count.
CoinFactorization::doForrestTomlin_
bool doForrestTomlin_
true if Forrest Tomlin update, false if PFI
Definition: CoinFactorization.hpp:1462
CoinFactorization::pivotRegion
CoinFactorizationDouble * pivotRegion() const
Returns address of pivot region.
Definition: CoinFactorization.hpp:159
CoinFactorization::addColumn
int addColumn(CoinBigIndex numberElements, int indicesRow[], double elements[])
Adds one Column to basis, can increase size of basis.
CoinFactorization::updateColumnTransposeLDensish
void updateColumnTransposeLDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by column.
CoinFactorization::numberFtranCounts_
int numberFtranCounts_
We can roll over factorizations.
Definition: CoinFactorization.hpp:1518
CoinFactorization::numberPivots_
int numberPivots_
Number pivots since last factorization.
Definition: CoinFactorization.hpp:1330
CoinFactorization::updateColumnTransposeRSparse
void updateColumnTransposeRSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when sparse.
CoinFactorization::areaFactor
double areaFactor() const
Whether larger areas needed.
Definition: CoinFactorization.hpp:235
CoinFactorization::numberDense
int numberDense() const
Returns number of dense rows.
Definition: CoinFactorization.hpp:302
CoinFactorization::btranAverageAfterU_
double btranAverageAfterU_
Definition: CoinFactorization.hpp:1525
CoinFactorization::maximumRowsExtra_
int maximumRowsExtra_
Maximum number of Rows after iterating.
Definition: CoinFactorization.hpp:1316
CoinFactorization::btranCountAfterL_
double btranCountAfterL_
Definition: CoinFactorization.hpp:1515
CoinFactorization::status
int status() const
Returns status.
Definition: CoinFactorization.hpp:137
CoinFactorization::denseThreshold
int denseThreshold() const
Gets dense threshold.
Definition: CoinFactorization.hpp:260
CoinFactorization::maximumColumnsExtra
int maximumColumnsExtra()
Maximum number of Columns after iterating.
Definition: CoinFactorization.hpp:347
CoinFactorization::sparseThreshold_
int sparseThreshold_
Below this use sparse technology - if 0 then no L row copy.
Definition: CoinFactorization.hpp:1538
CoinFactorization::indexColumnL
int * indexColumnL() const
Index of column in row for L.
Definition: CoinFactorization.hpp:185
CoinFactorization::deleteLink
void deleteLink(int index)
Deletes a link in chain of equal counts.
Definition: CoinFactorization.hpp:685
CoinFactorization::checkSparse
void checkSparse()
See if worth going sparse.
CoinFactorization::pivotColumn
int * pivotColumn() const
Returns address of pivotColumn region (also used for permuting)
Definition: CoinFactorization.hpp:155
CoinFactorization::lengthAreaL
CoinBigIndex lengthAreaL() const
Returns length of L area.
Definition: CoinFactorization.hpp:321
CoinFactorization::lastColumn_
CoinIntArrayWithLength lastColumn_
Previous Column in memory order.
Definition: CoinFactorization.hpp:1381
CoinFactorization::elementL_
CoinFactorizationDoubleArrayWithLength elementL_
Elements of L.
Definition: CoinFactorization.hpp:1453
CoinTypes.hpp
CoinFactorization::setNumberRows
void setNumberRows(int value)
Set number of Rows after factorization.
Definition: CoinFactorization.hpp:201
CoinFactorization::collectStatistics
bool collectStatistics() const
For statistics.
Definition: CoinFactorization.hpp:579
CoinFactorization::setForrestTomlin
void setForrestTomlin(bool value)
Definition: CoinFactorization.hpp:287
CoinFactorization::updateColumnTransposeUSparsish
void updateColumnTransposeUSparsish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when sparsish, assumes index is sorted i.e.
CoinFactorization::status_
int status_
Status of factorization.
Definition: CoinFactorization.hpp:1345
COINFACTORIZATION_SHIFT_PER_INT
#define COINFACTORIZATION_SHIFT_PER_INT
Definition: CoinFactorization.hpp:808
CoinFactorization::updateColumnTransposeR
void updateColumnTransposeR(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR)
CoinFactorization::pivotRowL_
CoinIntArrayWithLength pivotRowL_
Pivots for L.
Definition: CoinFactorization.hpp:1405
CoinFactorization::startColumnL
CoinBigIndex * startColumnL() const
Start of each column in L.
Definition: CoinFactorization.hpp:181
CoinFactorization::pivotRowSingleton
bool pivotRowSingleton(int pivotRow, int pivotColumn)
Does one pivot on Row Singleton in factorization.
CoinFactorization::relaxAccuracyCheck
void relaxAccuracyCheck(double value)
Allows change of pivot accuracy check 1.0 == none &gt;1.0 relaxed.
Definition: CoinFactorization.hpp:244
CoinFactorization::sort
void sort() const
Debug - sort so can compare.
CoinFactorization::numberRows
int numberRows() const
Number of Rows after factorization.
Definition: CoinFactorization.hpp:204
CoinFactorization::~CoinFactorization
~CoinFactorization()
Destructor.
CoinFactorization::updateColumn
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 &gt;=0...
CoinFactorization::btranCountAfterR_
double btranCountAfterR_
Definition: CoinFactorization.hpp:1514
CoinFactorization::maximumCoefficient
double maximumCoefficient() const
Returns maximum absolute value in factorization.
CoinFactorization::permute
int * permute() const
Returns address of permute region.
Definition: CoinFactorization.hpp:151
CoinFactorization::numberGoodU_
int numberGoodU_
Number factorized in U (not row singletons)
Definition: CoinFactorization.hpp:1324
CoinFactorization::CoinFactorization
CoinFactorization()
Default constructor.
CoinFactorization::deleteRow
int deleteRow(int Row)
Deletes one Row from basis, returns rank.
CoinFactorization::startColumnR_
CoinBigIndexArrayWithLength startColumnR_
Start of columns for R.
Definition: CoinFactorization.hpp:1480
CoinFactorization::factorizePart1
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.
CoinFactorization::btranAverageAfterR_
double btranAverageAfterR_
Definition: CoinFactorization.hpp:1526
CoinFactorization::denseArea_
double * denseArea_
Dense area.
Definition: CoinFactorization.hpp:1483
CoinFactorization::markRow_
CoinIntArrayWithLength markRow_
Marks rows to be updated.
Definition: CoinFactorization.hpp:1393
CoinFactorization::numberRowsExtra
int numberRowsExtra() const
Number of Rows after iterating.
Definition: CoinFactorization.hpp:197
CoinFactorization::gutsOfInitialize
void gutsOfInitialize(int type)
1 bit - tolerances etc, 2 more, 4 dummy arrays
CoinFactorization::pivot
bool pivot(int pivotRow, int pivotColumn, CoinBigIndex pivotRowPosition, CoinBigIndex pivotColumnPosition, CoinFactorizationDouble work[], unsigned int workArea2[], int increment2, T markRow[], int largeInteger)
Definition: CoinFactorization.hpp:812
CoinFactorization::numberElements
int numberElements() const
Total number of elements in factorization.
Definition: CoinFactorization.hpp:223
CoinFactorization::updateColumnTransposeLByRow
void updateColumnTransposeLByRow(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by row.
CoinFactorization::updateColumnTranspose
int updateColumnTranspose(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const
Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - i...
CoinFactorization::updateColumnFT
int updateColumnFT(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2)
Updates one column (FTRAN) from regionSparse2 Tries to do FT update number returned is negative if no...
CoinFactorization::updateColumnL
void updateColumnL(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL)
CoinFactorization::numberColumns
int numberColumns() const
Total number of columns in factorization.
Definition: CoinFactorization.hpp:219
CoinFactorization::relaxCheck_
double relaxCheck_
Relax check on accuracy in replaceColumn.
Definition: CoinFactorization.hpp:1310
CoinFactorization::updateTwoColumnsUDensish
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::cleanup
void cleanup()
Cleans up at end of factorization.
CoinFactorization::ftranAverageAfterR_
double ftranAverageAfterR_
Definition: CoinFactorization.hpp:1523
CoinFactorization::lengthR_
CoinBigIndex lengthR_
Length of R stuff.
Definition: CoinFactorization.hpp:1468
CoinFactorization::getRowSpaceIterate
bool getRowSpaceIterate(int iRow, int extraNeeded)
Gets space for one Row with given length while iterating, may have to do compression (returns True i...
CoinFactorization::numberInRow
int * numberInRow() const
Number of entries in each row.
Definition: CoinFactorization.hpp:332
CoinFactorization::restoreFactorization
int restoreFactorization(const char *file, bool factor=false)
Debug - restore from file - 0 if no error on file.
CoinFactorization::operator=
CoinFactorization & operator=(const CoinFactorization &other)
= copy
CoinFactorization::pivotColumnBack
int * pivotColumnBack() const
Returns address of pivotColumnBack region (also used for permuting) Now uses firstCount to save memor...
Definition: CoinFactorization.hpp:172
CoinFactorization::updateColumnTransposeRDensish
void updateColumnTransposeRDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when dense.
CoinFactorization::startColumnU
CoinBigIndex * startColumnU() const
Start of each column in U.
Definition: CoinFactorization.hpp:344
CoinFactorization::checkPivot
int checkPivot(double saveFromU, double oldPivot) const
Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular. ...
CoinFactorization::zeroTolerance
double zeroTolerance() const
Zero tolerance.
Definition: CoinFactorization.hpp:271
CoinFactorization::replaceColumn
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...
CoinFactorization::maximumU_
CoinBigIndex maximumU_
Maximum space used in U.
Definition: CoinFactorization.hpp:1417
CoinFactorization::updateColumnTransposeLSparse
void updateColumnTransposeLSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparse (by Row)
CoinFactorization::denseAreaAddress_
double * denseAreaAddress_
Dense area - actually used (for alignment etc)
Definition: CoinFactorization.hpp:1486
CoinFactorization::lengthU_
CoinBigIndex lengthU_
Base of U is always 0.
Definition: CoinFactorization.hpp:1423
CoinFactorization::updateColumnPFI
void updateColumnPFI(CoinIndexedVector *regionSparse) const
Updates part of column PFI (FTRAN) (after rest)
CoinFactorization::pivotTolerance_
double pivotTolerance_
Pivot tolerance.
Definition: CoinFactorization.hpp:1296
collectStatistics_
#define collectStatistics_
For statistics.
Definition: CoinFactorization.hpp:1534
CoinFactorization::updateTwoColumnsFT
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...
CoinFactorization::saveFactorization
int saveFactorization(const char *file) const
Debug - save on file - 0 if no error.
CoinFactorization::gutsOfCopy
void gutsOfCopy(const CoinFactorization &other)
CoinFactorization::numberInColumn
int * numberInColumn() const
Number of entries in each column.
Definition: CoinFactorization.hpp:335
CoinFactorization::factorSparse
int factorSparse()
Does sparse phase of factorization return code is &lt;0 error, 0= finished.
CoinFactorization::numberRowsExtra_
int numberRowsExtra_
Number of Rows after iterating.
Definition: CoinFactorization.hpp:1314
CoinFactorization::lengthL_
CoinBigIndex lengthL_
Length of L.
Definition: CoinFactorization.hpp:1447
CoinFactorization::numberInColumn_
CoinIntArrayWithLength numberInColumn_
Number in each Column.
Definition: CoinFactorization.hpp:1362
CoinFactorization::updateColumnLSparse
void updateColumnLSparse(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparse.
CoinFactorization::sparseThreshold
int sparseThreshold() const
get sparse threshold
Definition: CoinFactorization.hpp:521
CoinFactorization::persistenceFlag_
int persistenceFlag_
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
Definition: CoinFactorization.hpp:1563
CoinFactorization::factor
int factor()
Does most of factorization.
CoinFactorization::setPersistenceFlag
void setPersistenceFlag(int value)
CoinFactorization::numberGoodColumns
int numberGoodColumns() const
Number of good columns in factorization.
Definition: CoinFactorization.hpp:231
CoinFactorizationDoubleArrayWithLength::array
CoinFactorizationDouble * array() const
Get Array.
Definition: CoinIndexedVector.hpp:682
CoinFactorization::replaceColumnPFI
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...
CoinFactorizationDouble
double CoinFactorizationDouble
Definition: CoinTypes.hpp:57
CoinFactorization::numberBtranCounts_
int numberBtranCounts_
Definition: CoinFactorization.hpp:1519
CoinFactorization::numberDense_
int numberDense_
Number of dense rows.
Definition: CoinFactorization.hpp:1492
CoinFactorization::updateColumnLSparsish
void updateColumnLSparsish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparsish.
CoinFactorization::addLink
void addLink(int index, int count)
Adds a link in chain of equal counts.
Definition: CoinFactorization.hpp:669
CoinFactorization::gutsOfDestructor
void gutsOfDestructor(int type=1)
The real work of constructors etc 0 just scalars, 1 bit normal.
CoinFactorization::deleteColumn
int deleteColumn(int Row)
Deletes one Column from basis, returns rank.
CoinFactorization::densePermute_
int * densePermute_
Dense permutation.
Definition: CoinFactorization.hpp:1489
CoinFactorization::updateColumnTransposePFI
void updateColumnTransposePFI(CoinIndexedVector *region) const
Updates part of column transpose PFI (BTRAN) (before rest)
CoinFactorization::messageLevel
int messageLevel() const
Level of detail of messages.
Definition: CoinFactorization.hpp:249
CoinFactorization::numberElementsL
CoinBigIndex numberElementsL() const
Returns number in L area.
Definition: CoinFactorization.hpp:317
CoinFactorization::getAccuracyCheck
double getAccuracyCheck() const
Definition: CoinFactorization.hpp:246
CoinFactorization::setBiasLU
void setBiasLU(int value)
Definition: CoinFactorization.hpp:354
CoinFactorization::pivots
int pivots() const
Returns number of pivots since factorization.
Definition: CoinFactorization.hpp:144
CoinBigIndexArrayWithLength
CoinBigIndex * version.
Definition: CoinIndexedVector.hpp:835
CoinIndexedVector
Indexed Vector.
Definition: CoinIndexedVector.hpp:104
CoinFactorization::nextCount_
CoinIntArrayWithLength nextCount_
Next Row/Column with count.
Definition: CoinFactorization.hpp:1372
CoinFactorization::startRowL_
CoinBigIndexArrayWithLength startRowL_
Start of each row in L.
Definition: CoinFactorization.hpp:1544
CoinFactorization::pivotColumnSingleton
bool pivotColumnSingleton(int pivotRow, int pivotColumn)
Does one pivot on Column Singleton in factorization.
CoinFactorization::updateColumnTransposeLSparsish
void updateColumnTransposeLSparsish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparsish by row.
CoinFactorization::lastRow_
CoinIntArrayWithLength lastRow_
Previous Row in memory order.
Definition: CoinFactorization.hpp:1387
CoinFactorization::startColumnL_
CoinBigIndexArrayWithLength startColumnL_
Start of each column in L.
Definition: CoinFactorization.hpp:1459
CoinFactorization::replaceColumnU
void replaceColumnU(CoinIndexedVector *regionSparse, CoinBigIndex *deleted, int internalPivotRow)
Combines BtranU and delete elements If deleted is NULL then delete elements otherwise store where ele...
CoinFactorization::denseThreshold_
int denseThreshold_
Dense threshold.
Definition: CoinFactorization.hpp:1495
CoinFactorization::almostDestructor
void almostDestructor()
Delete all stuff (leaves as after CoinFactorization())
CoinFactorization::CoinFactorizationUnitTest
friend void CoinFactorizationUnitTest(const std::string &mpsDir)
COINFACTORIZATION_MASK_PER_INT
#define COINFACTORIZATION_MASK_PER_INT
Definition: CoinFactorization.hpp:809
CoinFactorization::firstCount_
CoinIntArrayWithLength firstCount_
First Row/Column with count of k, can tell which by offset - Rows then Columns.
Definition: CoinFactorization.hpp:1369
CoinFactorization::lastRow
int * lastRow() const
Returns address of lastRow region.
Definition: CoinFactorization.hpp:167
COIN_RESTRICT
#define COIN_RESTRICT
Definition: CoinHelperFunctions.hpp:32
CoinFactorization::setNumberElementsU
void setNumberElementsU(CoinBigIndex value)
Setss number in U area.
Definition: CoinFactorization.hpp:310
CoinFactorization::sparse_
CoinIntArrayWithLength sparse_
Sparse regions.
Definition: CoinFactorization.hpp:1553
CoinFactorization::elementR_
CoinFactorizationDouble * elementR_
Elements of R.
Definition: CoinFactorization.hpp:1474
CoinFactorization::lengthAreaU_
CoinBigIndex lengthAreaU_
Length of area reserved for U.
Definition: CoinFactorization.hpp:1426
CoinFactorization::updateColumnTransposeL
void updateColumnTransposeL(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL)
CoinFactorization::updateColumnRFT
void updateColumnRFT(CoinIndexedVector *region, int *indexIn)
Updates part of column (FTRANR) with FT update.
CoinFactorization::indexRowL
int * indexRowL() const
Row indices of L.
Definition: CoinFactorization.hpp:189
CoinFactorization::setStatus
void setStatus(int value)
Sets status.
Definition: CoinFactorization.hpp:141
CoinFactorization::getColumnSpaceIterate
CoinBigIndex getColumnSpaceIterate(int iColumn, double value, int iRow)
getColumnSpaceIterate.
CoinFactorization::ftranAverageAfterU_
double ftranAverageAfterU_
Definition: CoinFactorization.hpp:1524
CoinFactorization::lengthAreaR_
CoinBigIndex lengthAreaR_
length of area reserved for R
Definition: CoinFactorization.hpp:1471
CoinFactorization::ftranAverageAfterL_
double ftranAverageAfterL_
While these are average ratios collected over last period.
Definition: CoinFactorization.hpp:1522
CoinFactorization::pivotColumn_
CoinIntArrayWithLength pivotColumn_
Pivot order for each Column.
Definition: CoinFactorization.hpp:1337
CoinFactorization::show_self
void show_self() const
Debug show object (shows one representation)
CoinFactorization::zeroTolerance_
double zeroTolerance_
Zero tolerance.
Definition: CoinFactorization.hpp:1298
CoinFactorization::numberU_
int numberU_
Number in U.
Definition: CoinFactorization.hpp:1414
CoinFactorization::biggerDimension_
int biggerDimension_
Larger of row and column size.
Definition: CoinFactorization.hpp:1399
CoinFactorization::addRow
int addRow(CoinBigIndex numberElements, int indicesColumn[], double elements[])
Adds one Row to basis, can increase size of basis.
CoinFactorization::biasLU_
int biasLU_
L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias.
Definition: CoinFactorization.hpp:1557
CoinFactorization::resetStatistics
void resetStatistics()
Reset all sparsity etc statistics.
CoinFactorization::areaFactor
void areaFactor(double value)
Definition: CoinFactorization.hpp:238
CoinFactorization::ftranCountAfterL_
double ftranCountAfterL_
Definition: CoinFactorization.hpp:1509
CoinFactorization::ftranCountAfterU_
double ftranCountAfterU_
Definition: CoinFactorization.hpp:1511
CoinFactorization::lengthAreaU
CoinBigIndex lengthAreaU() const
Returns length of U area.
Definition: CoinFactorization.hpp:313
CoinFactorization::maximumPivots
int maximumPivots() const
Maximum number of pivots between factorizations.
Definition: CoinFactorization.hpp:254
CoinFactorization::adjustedAreaFactor
double adjustedAreaFactor() const
Returns areaFactor but adjusted for dense.
CoinFactorization::factorSparseLarge
int factorSparseLarge()
Does sparse phase of factorization (for larger problems) return code is &lt;0 error, 0= finished...
CoinFactorization::numberL
CoinBigIndex numberL() const
Number in L.
Definition: CoinFactorization.hpp:208
CoinFactorization::ftranCountInput_
double ftranCountInput_
Below are all to collect.
Definition: CoinFactorization.hpp:1508
CoinFactorization::numberTrials_
int numberTrials_
0 - no increasing rows - no permutations, 1 - no increasing rows but permutations 2 - increasing rows...
Definition: CoinFactorization.hpp:1354
CoinFactorization::convertRowToColumnU_
CoinBigIndexArrayWithLength convertRowToColumnU_
Converts rows to columns in U.
Definition: CoinFactorization.hpp:1438
CoinFactorization::updateColumnUSparsish
void updateColumnUSparsish(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparsish.
CoinFactorization::nextRow_
CoinIntArrayWithLength nextRow_
Next Row in memory order.
Definition: CoinFactorization.hpp:1384
CoinFactorization::elementU_
CoinFactorizationDoubleArrayWithLength elementU_
Elements of U.
Definition: CoinFactorization.hpp:1429
CoinFactorization::slackValue
double slackValue() const
Whether slack value is +1 or -1.
Definition: CoinFactorization.hpp:277
CoinPackedMatrix
Sparse Matrix Base Class.
Definition: CoinPackedMatrix.hpp:79
CoinFactorization::factorizePart2
int factorizePart2(int permutation[], int exactNumberElements)
This is part two of factorization Arrays belong to factorization and were returned by part 1 If statu...
CoinFactorization::numberColumns_
int numberColumns_
Number of Columns in factorization.
Definition: CoinFactorization.hpp:1318
CoinFactorization::indexColumnU_
CoinIntArrayWithLength indexColumnU_
Base address for U (may change)
Definition: CoinFactorization.hpp:1402
CoinFactorization::updateColumnUSparse
void updateColumnUSparse(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparse.
CoinFactorization::workArea_
CoinFactorizationDoubleArrayWithLength workArea_
First work area.
Definition: CoinFactorization.hpp:1498
CoinFactorization::saveColumn_
CoinIntArrayWithLength saveColumn_
Columns left to do in a single pivot.
Definition: CoinFactorization.hpp:1390
CoinFactorization::indexRowR_
int * indexRowR_
Row indices for R.
Definition: CoinFactorization.hpp:1477
CoinFactorization::clearArrays
void clearArrays()
Get rid of all memory.
Definition: CoinFactorization.hpp:532
CoinFactorization::btranAverageAfterL_
double btranAverageAfterL_
Definition: CoinFactorization.hpp:1527
CoinFactorization::updateColumnTransposeUDensish
void updateColumnTransposeUDensish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when densish, assumes index is sorted i.e.
CoinFactorization::factorDense
int factorDense()
Does dense phase of factorization return code is &lt;0 error, 0= finished.
CoinFactorization::numberInColumnPlus_
CoinIntArrayWithLength numberInColumnPlus_
Number in each Column including pivoted.
Definition: CoinFactorization.hpp:1365
CoinFactorization::updateColumnUDensish
int updateColumnUDensish(double *COIN_RESTRICT region, int *COIN_RESTRICT regionIndex) const
Updates part of column (FTRANU)
CoinFactorization::pivotColumnBack_
CoinIntArrayWithLength pivotColumnBack_
Inverse Pivot order for each Column.
Definition: CoinFactorization.hpp:1343
CoinFactorization::startColumnU_
CoinBigIndexArrayWithLength startColumnU_
Start of each column in U.
Definition: CoinFactorization.hpp:1435
CoinFactorization::baseL_
CoinBigIndex baseL_
Base of L.
Definition: CoinFactorization.hpp:1444
CoinFactorization::numberElementsU
CoinBigIndex numberElementsU() const
Returns number in U area.
Definition: CoinFactorization.hpp:306
CoinFactorization::permuteBack_
CoinIntArrayWithLength permuteBack_
DePermutation vector for pivot row order.
Definition: CoinFactorization.hpp:1341
CoinFactorization::slackValue_
double slackValue_
Whether slack value is +1 or -1.
Definition: CoinFactorization.hpp:1301
CoinFactorization::goSparse
void goSparse()
makes a row copy of L for speed and to allow very sparse problems
CoinFactorizationDoubleArrayWithLength
CoinFactorizationDouble * version.
Definition: CoinIndexedVector.hpp:673
CoinFactorization::indexColumnL_
CoinIntArrayWithLength indexColumnL_
Index of column in row for L.
Definition: CoinFactorization.hpp:1547
CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:105
CoinFactorization::indexRowL_
CoinIntArrayWithLength indexRowL_
Row indices of L.
Definition: CoinFactorization.hpp:1456
CoinFactorization::numberCompressions_
CoinBigIndex numberCompressions_
Number of compressions done.
Definition: CoinFactorization.hpp:1504
CoinFactorization::lengthAreaL_
CoinBigIndex lengthAreaL_
Length of area reserved for L.
Definition: CoinFactorization.hpp:1450
CoinFactorization::permute_
CoinIntArrayWithLength permute_
Permutation vector for pivot row order.
Definition: CoinFactorization.hpp:1339
CoinFactorization::add
int add(CoinBigIndex numberElements, int indicesRow[], int indicesColumn[], double elements[])
Adds given elements to Basis and updates factorization, can increase size of basis.
CoinFactorization::updateColumnTransposeUSparse
void updateColumnTransposeUSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANU) when sparse, assumes index is sorted i.e.
CoinFactorization::indexRowU
int * indexRowU() const
Row indices of U.
Definition: CoinFactorization.hpp:341
CoinFactorization::workArea2_
CoinUnsignedIntArrayWithLength workArea2_
Second work area.
Definition: CoinFactorization.hpp:1501
CoinFactorization
This deals with Factorization and Updates.
Definition: CoinFactorization.hpp:50
CoinFactorization::getColumnSpace
bool getColumnSpace(int iColumn, int extraNeeded)
Gets space for one Column with given length, may have to do compression (returns True if successful)...
CoinFactorization::updateColumnR
void updateColumnR(CoinIndexedVector *region) const
Updates part of column (FTRANR) without FT update.
CoinFactorization::areaFactor_
double areaFactor_
How much to multiply areas by.
Definition: CoinFactorization.hpp:1308
CoinFactorization::checkConsistency
void checkConsistency()
Checks that row and column copies look OK.
CoinFactorization::totalElements_
CoinBigIndex totalElements_
Number of elements in U (to go) or while iterating total overall.
Definition: CoinFactorization.hpp:1333
CoinIntArrayWithLength::array
int * array() const
Get Array.
Definition: CoinIndexedVector.hpp:790
CoinFactorization::updateColumnU
void updateColumnU(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANU)
CoinFactorization::updateColumnTransposeU
void updateColumnTransposeU(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU), assumes index is sorted i.e.
CoinFactorization::numberSlacks_
int numberSlacks_
Number of slacks at beginning of U.
Definition: CoinFactorization.hpp:1411
CoinFactorization::numberColumnsExtra_
int numberColumnsExtra_
Number of Columns after iterating.
Definition: CoinFactorization.hpp:1320
CoinFactorization::getAreas
void getAreas(int numberRows, int numberColumns, CoinBigIndex maximumL, CoinBigIndex maximumU)
Gets space for a factorization, called by constructors.
CoinFactorization::numberInRow_
CoinIntArrayWithLength numberInRow_
Number in each Row.
Definition: CoinFactorization.hpp:1359
CoinIntArrayWithLength
int * version
Definition: CoinIndexedVector.hpp:781
CoinIndexedVector.hpp
CoinFactorization::numberForrestTomlin
int numberForrestTomlin() const
Length of FT vector.
Definition: CoinFactorization.hpp:227
CoinFactorization::setDenseThreshold
void setDenseThreshold(int value)
Sets dense threshold.
Definition: CoinFactorization.hpp:263
CoinFactorization::messageLevel_
int messageLevel_
Detail in messages.
Definition: CoinFactorization.hpp:1396
CoinFactorization::lastCount_
CoinIntArrayWithLength lastCount_
Previous Row/Column with count.
Definition: CoinFactorization.hpp:1375
CoinFactorization::updateColumnTransposeUByColumn
void updateColumnTransposeUByColumn(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) by column assumes index is sorted i.e.
CoinFactorization::btranCountAfterU_
double btranCountAfterU_
Definition: CoinFactorization.hpp:1513
CoinFactorization::elementByRowL
CoinFactorizationDouble * elementByRowL() const
Elements in L (row copy)
Definition: CoinFactorization.hpp:193
CoinFactorization::maximumPivots_
int maximumPivots_
Maximum number of pivots before factorization.
Definition: CoinFactorization.hpp:1328
CoinFactorization::spaceForForrestTomlin
bool spaceForForrestTomlin() const
True if FT update and space.
Definition: CoinFactorization.hpp:290
CoinFactorization::reorderU
bool reorderU()
Reorders U so contiguous and in order (if there is space) Returns true if it could.
CoinFactorization::preProcess
void preProcess(int state, int possibleDuplicates=-1)
PreProcesses raw triplet data.
CoinFactorization::maximumColumnsExtra_
int maximumColumnsExtra_
Maximum number of Columns after iterating.
Definition: CoinFactorization.hpp:1322
CoinFactorization::maximumRowsExtra
int maximumRowsExtra() const
Maximum of Rows after iterating.
Definition: CoinFactorization.hpp:215
CoinFactorization::persistenceFlag
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...
Definition: CoinFactorization.hpp:361
CoinFactorization::biasLU
int biasLU() const
L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias.
Definition: CoinFactorization.hpp:352
CoinFactorization::sparseThreshold2_
int sparseThreshold2_
And one for &quot;sparsish&quot;.
Definition: CoinFactorization.hpp:1541
CoinFactorization::numberGoodL_
int numberGoodL_
Number factorized in L.
Definition: CoinFactorization.hpp:1326
CoinFactorization::conditionNumber
double conditionNumber() const
Condition number - product of pivots after factorization.
CoinFactorization::pivotTolerance
double pivotTolerance() const
Pivot tolerance.
Definition: CoinFactorization.hpp:266
CoinFactorization::elementByRowL_
CoinFactorizationDoubleArrayWithLength elementByRowL_
Elements in L (row copy)
Definition: CoinFactorization.hpp:1550
CoinFactorization::numberRows_
int numberRows_
Number of Rows in factorization.
Definition: CoinFactorization.hpp:1312
CoinFactorization::setCollectStatistics
void setCollectStatistics(bool onOff) const
For statistics.
Definition: CoinFactorization.hpp:582
CoinFactorization::updateColumnLDensish
void updateColumnLDensish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when densish.
CoinFactorization::numberCompressions
CoinBigIndex numberCompressions() const
Number of compressions done.
Definition: CoinFactorization.hpp:329
CoinFactorization::baseL
CoinBigIndex baseL() const
Base of L.
Definition: CoinFactorization.hpp:212
CoinFactorization::btranCountInput_
double btranCountInput_
Definition: CoinFactorization.hpp:1512
CoinFactorization::replaceRow
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...
CoinFactorization::factorSparseSmall
int factorSparseSmall()
Does sparse phase of factorization (for smaller problems) return code is &lt;0 error, 0= finished.
CoinFactorization::indexRowU_
CoinIntArrayWithLength indexRowU_
Row indices of U.
Definition: CoinFactorization.hpp:1432
CoinFactorization::forrestTomlin
bool forrestTomlin() const
true if Forrest Tomlin update, false if PFI
Definition: CoinFactorization.hpp:285
CoinFactorization::emptyRows
void emptyRows(int numberToEmpty, const int which[])
Takes out all entries for given rows.
CoinFactorization::factorize
int factorize(const CoinPackedMatrix &matrix, int rowIsBasic[], int columnIsBasic[], double areaFactor=0.0)
When part of LP - given by basic variables.
CoinFactorization::getRowSpace
bool getRowSpace(int iRow, int extraNeeded)
Gets space for one Row with given length, may have to do compression (returns True if successful)...
CoinFactorization::numberElementsR
CoinBigIndex numberElementsR() const
Returns number in R area.
Definition: CoinFactorization.hpp:325
CoinFactorization::permuteBack
int * permuteBack() const
Returns address of permuteBack region.
Definition: CoinFactorization.hpp:163