Cgl 0.59.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
CoinAbcBaseFactorization.hpp
Go to the documentation of this file.
1 /* $Id: CoinAbcBaseFactorization.hpp 1910 2013-01-27 02:00:13Z stefan $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others, Copyright (C) 2012, FasterCoin. 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 */
18 #include "AbcCommon.hpp"
19 #include "CoinAbcHelperFunctions.hpp"
20 #if ABC_PARALLEL
21 #define FACTOR_CPU 4
22 #else
23 #define FACTOR_CPU 1
24 #endif
25 #define LARGE_SET COIN_INT_MAX-10
26 #define LARGE_UNSET (LARGE_SET+1)
27
28 class CoinAbcTypeFactorization : public
29 CoinAbcAnyFactorization
30 {
31 friend void CoinAbcFactorizationUnitTest( const std::string & mpsDir );
32
33 public:
34
37 CoinAbcTypeFactorization ( );
40 CoinAbcTypeFactorization ( const CoinAbcTypeFactorization &other);
42 CoinAbcTypeFactorization ( const CoinFactorization &other);
43
45 virtual ~CoinAbcTypeFactorization ( );
47 virtual CoinAbcAnyFactorization * clone() const ;
49 void almostDestructor();
51 void show_self ( ) const;
53 void sort ( ) const;
55 CoinAbcTypeFactorization & operator = ( const CoinAbcTypeFactorization & other );
57
60 CoinSimplexDouble conditionNumber() const;
62
64
67 inline CoinSimplexInt *permute ( ) const {
69 return NULL; //permute_.array();
70 }
72 virtual inline CoinSimplexInt * indices() const
73 { return indexRowU_.array();}
75 virtual inline CoinSimplexInt *pivotColumn ( ) const {
76 return pivotColumn_.array();
77 }
79 virtual inline CoinFactorizationDouble *pivotRegion ( ) const {
80 return pivotRegionAddress_;
81 }
82 #if ABC_SMALL<2
83 inline CoinBigIndex * startRowL() const
85 { return startRowL_.array();}
86 #endif
87
89 inline CoinBigIndex * startColumnL() const
90 { return startColumnL_.array();}
91
92 #if ABC_SMALL<2
93 inline CoinSimplexInt * indexColumnL() const
95 { return indexColumnL_.array();}
96 #endif
97
99 inline CoinSimplexInt * indexRowL() const
100 { return indexRowL_.array();}
101
102 #if ABC_SMALL<2
103 inline CoinFactorizationDouble * elementByRowL() const
105 { return elementByRowL_.array();}
106 #endif
107
110 inline CoinSimplexInt * pivotLinkedBackwards() const
111 { return firstCount_.array()+numberRows_+1;}
112 inline CoinSimplexInt * pivotLinkedForwards() const
113 { return firstCount_.array()+2*numberRows_+3;}
114 inline CoinSimplexInt * pivotLOrder() const
115 { return firstCount_.array();}
116 #if ABC_SMALL<0
117 #define ABC_USE_FUNCTION_POINTERS 0
118 #define SMALL_PERMUTE
119 #endif
120 #ifdef ABC_USE_FUNCTION_POINTERS
121 typedef void (*scatterUpdate) (int,CoinFactorizationDouble,const CoinFactorizationDouble *, CoinFactorizationDouble *);
122 #if ABC_USE_FUNCTION_POINTERS
123 typedef struct {
124 scatterUpdate functionPointer;
125 CoinBigIndex offset;
126 int number;
127 } scatterStruct;
128 #else
129 typedef struct {
130 CoinBigIndex offset;
131 int number;
132 } scatterStruct;
133 #endif
134 inline scatterStruct * scatterUColumn() const
136 { return scatterPointersUColumnAddress_;}
137 #endif
138
140
143 inline CoinSimplexInt * firstCount() const
144 { return firstCount_.array();}
145
147 inline CoinSimplexInt * nextCount() const
148 { return firstCount_.array()+numberRows_+2;}
149
151 inline CoinSimplexInt * lastCount() const
152 { return firstCount_.array()+3*numberRows_+2;}
153
155 inline CoinSimplexInt numberRowsExtra ( ) const {
156 return numberRowsExtra_;
157 }
159 inline CoinBigIndex numberL() const
160 { return numberL_;}
161
163 inline CoinBigIndex baseL() const
164 { return baseL_;}
166 inline CoinSimplexInt maximumRowsExtra ( ) const {
167 return maximumRowsExtra_;
168 }
170 virtual inline CoinBigIndex numberElements ( ) const {
171 return totalElements_;
172 }
174 inline CoinSimplexInt numberForrestTomlin ( ) const {
175 return numberInColumn_.array()[numberRowsExtra_];
176 }
178 CoinSimplexDouble adjustedAreaFactor() const;
180 inline CoinSimplexInt messageLevel ( ) const {
181 return messageLevel_ ;
182 }
183 void messageLevel ( CoinSimplexInt value );
185 virtual void maximumPivots ( CoinSimplexInt value );
186
187 #if ABC_SMALL<4
188 inline CoinSimplexInt denseThreshold() const
190 { return denseThreshold_;}
192 inline void setDenseThreshold(CoinSimplexInt value)
193 { denseThreshold_ = value;}
194 #endif
195 CoinSimplexDouble maximumCoefficient() const;
197 #if 0
198 inline bool forrestTomlin() const
200 { return doForrestTomlin_;}
201 inline void setForrestTomlin(bool value)
202 { doForrestTomlin_=value;}
203 #endif
204 inline bool spaceForForrestTomlin() const
206 {
207 CoinBigIndex start = lastEntryByColumnU_;
208 CoinBigIndex space = lengthAreaU_ - ( start + numberRowsExtra_ );
209 return (space>=0); //&&doForrestTomlin_;
210 }
212
215
216
218 inline CoinBigIndex numberElementsU ( ) const {
219 return lengthU_;
220 }
222 inline void setNumberElementsU(CoinBigIndex value)
223 { lengthU_ = value; }
225 inline CoinBigIndex lengthAreaU ( ) const {
226 return lengthAreaU_;
227 }
229 inline CoinBigIndex numberElementsL ( ) const {
230 return lengthL_;
231 }
233 inline CoinBigIndex lengthAreaL ( ) const {
234 return lengthAreaL_;
235 }
237 inline CoinBigIndex numberElementsR ( ) const {
238 return lengthR_;
239 }
241 inline CoinBigIndex numberCompressions() const
242 { return numberCompressions_;}
244 //virtual CoinSimplexInt * pivotRow() const;
246 //virtual CoinFactorizationDouble * workArea() const;
248 //virtual CoinSimplexInt * intWorkArea() const;
250 virtual inline CoinBigIndex * starts() const
251 { return startColumnU_.array();}
253 virtual inline CoinSimplexInt * numberInRow() const
254 { return numberInRow_.array();}
256 virtual inline CoinSimplexInt * numberInColumn() const
257 { return numberInColumn_.array();}
259 virtual inline CoinFactorizationDouble * elements() const
260 { return elementU_.array();}
262 inline CoinBigIndex * startColumnR() const
263 {return reinterpret_cast<CoinBigIndex *>(firstCount_.array()+3*numberRows_+4);}
265 inline CoinFactorizationDouble * elementU() const
266 { return elementU_.array();}
268 inline CoinSimplexInt * indexRowU() const
269 { return indexRowU_.array();}
271 inline CoinBigIndex * startColumnU() const
272 { return startColumnU_.array();}
273 #if COIN_BIG_DOUBLE==1
274 void toLongArray(CoinIndexedVector * vector,int which) const;
277 void fromLongArray(CoinIndexedVector * vector) const;
279 void fromLongArray(int which) const;
281 long double * denseVector(CoinIndexedVector * vector) const;
283 long double * denseVector(CoinIndexedVector & vector) const;
285 const long double * denseVector(const CoinIndexedVector * vector) const;
287 const long double * denseVector(const CoinIndexedVector & vector) const;
289 void scan(CoinIndexedVector * vector) const;
291 void clearHiddenArrays();
292 #else
293 inline double * denseVector(CoinIndexedVector * vector) const
295 {return vector->denseVector();}
296 inline double * denseVector(CoinIndexedVector & vector) const
297 {return vector.denseVector();}
299 inline const double * denseVector(const CoinIndexedVector * vector) const
300 {return vector->denseVector();}
301 inline const double * denseVector(const CoinIndexedVector & vector) const
302 {return vector.denseVector();}
304 inline void toLongArray(CoinIndexedVector * vector,int which) const {}
306 inline void fromLongArray(CoinIndexedVector * vector) const {}
308 inline void fromLongArray(int which) const {}
310 inline void scan(CoinIndexedVector * vector) const
311 {vector->scan(0,numberRows_,zeroTolerance_);}
312 #endif
313 #ifdef ABC_ORDERED_FACTORIZATION
314 void permuteInForFtran(CoinIndexedVector & regionSparse,bool full=false) const ;
317 void permuteInForBtranAndMultiply(CoinIndexedVector & regionSparse, bool full=false) const ;
319 void permuteOutForBtran(CoinIndexedVector & regionSparse) const ;
320 #endif
321
326 //inline CoinSimplexInt persistenceFlag() const
327 //{ return persistenceFlag_;}
329
332 #if 0
333
337 virtual int checkReplace ( const AbcSimplex * model,
338 CoinIndexedVector * regionSparse,
339 int pivotRow,
340 CoinSimplexDouble & pivotCheck,
341 double acceptablePivot = 1.0e-8);
346 virtual CoinSimplexInt replaceColumn ( CoinIndexedVector * regionSparse,
347 CoinSimplexInt pivotRow,
348 CoinSimplexDouble pivotCheck ,
349 bool skipBtranU=false,
350 CoinSimplexDouble acceptablePivot=1.0e-8);
351 #endif
352
356 virtual
357 #ifdef ABC_LONG_FACTORIZATION
358 long
359 #endif
360 double checkReplacePart1 ( CoinIndexedVector * regionSparse,
361 int pivotRow);
366 virtual
367 #ifdef ABC_LONG_FACTORIZATION
368 long
369 #endif
370 double checkReplacePart1 ( CoinIndexedVector * regionSparse,
371 CoinIndexedVector * partialUpdate,
372 int pivotRow);
373 #ifdef MOVE_REPLACE_PART1A
374
378 virtual void checkReplacePart1a ( CoinIndexedVector * regionSparse,
379 int pivotRow);
380 virtual
381 #ifdef ABC_LONG_FACTORIZATION
382 long
383 #endif
384 double checkReplacePart1b ( CoinIndexedVector * regionSparse,
385 int pivotRow);
386 #endif
387
389 virtual int checkReplacePart2 ( int pivotRow,
390 CoinSimplexDouble btranAlpha,
391 double ftranAlpha,
392 #ifdef ABC_LONG_FACTORIZATION
393 long
394 #endif
395 double ftAlpha,
396 double acceptablePivot = 1.0e-8);
399 virtual void replaceColumnPart3 ( const AbcSimplex * model,
400 CoinIndexedVector * regionSparse,
401 CoinIndexedVector * tableauColumn,
402 int pivotRow,
403 #ifdef ABC_LONG_FACTORIZATION
404 long
405 #endif
406 double alpha );
409 virtual void replaceColumnPart3 ( const AbcSimplex * model,
410 CoinIndexedVector * regionSparse,
411 CoinIndexedVector * tableauColumn,
412 CoinIndexedVector * partialUpdate,
413 int pivotRow,
414 #ifdef ABC_LONG_FACTORIZATION
415 long
416 #endif
417 double alpha );
418 #ifdef EARLY_FACTORIZE
419 virtual int replaceColumns ( const AbcSimplex * model,
421 CoinIndexedVector & stuff,
422 int firstPivot,int lastPivot,bool cleanUp);
423 #endif
424 void updatePartialUpdate(CoinIndexedVector & partialUpdate);
427 inline virtual bool wantsTableauColumn() const
428 {return false;}
432 int replaceColumnU ( CoinIndexedVector * regionSparse,
433 CoinBigIndex * deletedPosition,
434 CoinSimplexInt * deletedColumns,
435 CoinSimplexInt pivotRow);
437
440
442
448 virtual CoinSimplexInt updateColumnFT ( CoinIndexedVector & regionSparse);
449 virtual int updateColumnFTPart1 ( CoinIndexedVector & regionSparse) ;
450 virtual void updateColumnFTPart2 ( CoinIndexedVector & regionSparse) ;
454 virtual void updateColumnFT ( CoinIndexedVector & regionSparseFT,
455 CoinIndexedVector & partialUpdate,
456 int which);
459 virtual CoinSimplexInt updateColumn ( CoinIndexedVector & regionSparse) const;
465 virtual CoinSimplexInt updateTwoColumnsFT ( CoinIndexedVector & regionFT,
466 CoinIndexedVector & regionOther);
471 virtual CoinSimplexInt updateColumnTranspose ( CoinIndexedVector & regionSparse) const;
473 virtual void updateFullColumn ( CoinIndexedVector & regionSparse) const;
475 virtual void updateFullColumnTranspose ( CoinIndexedVector & regionSparse) const;
477 virtual void updateWeights ( CoinIndexedVector & regionSparse) const;
479 virtual void updateColumnCpu ( CoinIndexedVector & regionSparse,int whichCpu) const;
481 virtual void updateColumnTransposeCpu ( CoinIndexedVector & regionSparse,int whichCpu) const;
482 void unpack ( CoinIndexedVector * regionFrom,
483 CoinIndexedVector * regionTo) const;
484 void pack ( CoinIndexedVector * regionFrom,
485 CoinIndexedVector * regionTo) const;
487 inline void goSparse() {}
488 void goSparse2();
489 #ifndef NDEBUG
490 virtual void checkMarkArrays() const;
491 #endif
492 #if ABC_SMALL<2
493
494 inline CoinSimplexInt sparseThreshold ( ) const
495 { return sparseThreshold_;}
496 #endif
497
498 void sparseThreshold ( CoinSimplexInt value );
500
505 inline void clearArrays()
507 { gutsOfDestructor();}
509
510 void checkSparse();
513 void gutsOfDestructor(CoinSimplexInt type=1);
515 void gutsOfInitialize(CoinSimplexInt type);
516 void gutsOfCopy(const CoinAbcTypeFactorization &other);
517
519 void resetStatistics();
520 void printRegion(const CoinIndexedVector & vector, const char * where) const;
521
523
525 virtual void getAreas ( CoinSimplexInt numberRows,
527 CoinSimplexInt numberColumns,
528 CoinBigIndex maximumL,
529 CoinBigIndex maximumU );
530
532 virtual void preProcess ( );
533 void preProcess (CoinSimplexInt );
535 double preProcess3 ( );
536 void preProcess4 ( );
538 virtual CoinSimplexInt factor (AbcSimplex * model);
539 #ifdef EARLY_FACTORIZE
540 virtual int factorize (AbcSimplex * model, CoinIndexedVector & stuff);
542 #endif
543 virtual void postProcess(const CoinSimplexInt * sequence, CoinSimplexInt * pivotVariable);
546 virtual void makeNonSingular(CoinSimplexInt * sequence);
547 protected:
550 CoinSimplexInt factorSparse ( );
553 CoinSimplexInt factorDense ( );
554
556 bool pivotOneOtherRow ( CoinSimplexInt pivotRow,
557 CoinSimplexInt pivotColumn );
559 bool pivotRowSingleton ( CoinSimplexInt pivotRow,
560 CoinSimplexInt pivotColumn );
562 void pivotColumnSingleton ( CoinSimplexInt pivotRow,
563 CoinSimplexInt pivotColumn );
565 void afterPivot( CoinSimplexInt pivotRow,
566 CoinSimplexInt pivotColumn );
568 int wantToGoDense();
569
574 bool getColumnSpace ( CoinSimplexInt iColumn,
575 CoinSimplexInt extraNeeded );
576
579 bool reorderU();
583 bool getColumnSpaceIterateR ( CoinSimplexInt iColumn, CoinFactorizationDouble value,
584 CoinSimplexInt iRow);
590 CoinBigIndex getColumnSpaceIterate ( CoinSimplexInt iColumn, CoinFactorizationDouble value,
591 CoinSimplexInt iRow);
595 bool getRowSpace ( CoinSimplexInt iRow, CoinSimplexInt extraNeeded );
596
600 bool getRowSpaceIterate ( CoinSimplexInt iRow,
601 CoinSimplexInt extraNeeded );
603 void checkConsistency ( );
604 //#define CHECK_LINKS
605 #ifdef CHECK_LINKS
606 void checkLinks(int x=0);
607 #else
608 # define checkLinks(x)
609 #endif
610 inline void addLink ( CoinSimplexInt index, CoinSimplexInt count ) {
612 CoinSimplexInt * COIN_RESTRICT nextCount = nextCountAddress_;
613 CoinSimplexInt * COIN_RESTRICT firstCount = this->firstCount();
614 CoinSimplexInt * COIN_RESTRICT lastCount = lastCountAddress_;
615 CoinSimplexInt next = firstCount[count];
616 firstCount[count] = index;
617 nextCount[index] = next;
618 lastCount[index] = count-numberRows_-2; // points to firstCount[count]
619 if (next>=0)
620 lastCount[next] = index;
621 }
623 inline void deleteLink ( CoinSimplexInt index ) {
624 CoinSimplexInt * COIN_RESTRICT nextCount = nextCountAddress_;
625 CoinSimplexInt * COIN_RESTRICT lastCount = lastCountAddress_;
626 CoinSimplexInt next = nextCount[index];
627 CoinSimplexInt last = lastCount[index];
628 assert (next!=index);
629 assert (last!=index);
630 if (next>=0)
631 lastCount[next] = last;
632 if (last>=0) {
633 nextCount[last] = next;
634 } else {
635 int count=last+numberRows_+2;
636 CoinSimplexInt * COIN_RESTRICT firstCount = this->firstCount();
637 firstCount[count]=next;
638 }
639 }
641 inline void modifyLink ( CoinSimplexInt index, CoinSimplexInt count ) {
642 CoinSimplexInt * COIN_RESTRICT nextCount = nextCountAddress_;
643 CoinSimplexInt * COIN_RESTRICT lastCount = lastCountAddress_;
644 CoinSimplexInt * COIN_RESTRICT firstCount = this->firstCount();
645 CoinSimplexInt next2 = firstCount[count];
646 if (next2==index)
647 return;
648 firstCount[count] = index;
649 CoinSimplexInt next = nextCount[index];
650 CoinSimplexInt last = lastCount[index];
651 assert (next!=index);
652 assert (last!=index);
653 nextCount[index] = next2;
654 lastCount[index] = count-numberRows_-2; // points to firstCount[count]
655 if (next>=0)
656 lastCount[next] = last;
657 if (next2>=0)
658 lastCount[next2] = index;
659 if (last>=0) {
660 nextCount[last] = next;
661 } else {
662 int count=last+numberRows_+2;
663 firstCount[count]=next;
664 }
665 }
667 void separateLinks();
668 void separateLinks(CoinSimplexInt,CoinSimplexInt);
670 void cleanup ( );
672 void doAddresses();
673
675 void updateColumnL ( CoinIndexedVector * region
676 #if ABC_SMALL<2
677 , CoinAbcStatistics & statistics
678 #endif
679 #if ABC_PARALLEL
680 ,int whichSparse=0
681 #endif
682 ) const;
684 void updateColumnLDensish ( CoinIndexedVector * region ) const;
686 void updateColumnLDense ( CoinIndexedVector * region ) const;
688 void updateColumnLSparse ( CoinIndexedVector * region
689 #if ABC_PARALLEL
690 ,int whichSparse
691 #endif
692 ) const;
693
695 void updateColumnR ( CoinIndexedVector * region
696 #if ABC_SMALL<2
697 , CoinAbcStatistics & statistics
698 #endif
699 #if ABC_PARALLEL
700 ,int whichSparse=0
701 #endif
702 ) const;
704 bool storeFT(
705 #if ABC_SMALL<3
706 const
707 #endif
708 CoinIndexedVector * regionFT);
710 void updateColumnU ( CoinIndexedVector * region
711 #if ABC_SMALL<2
712 , CoinAbcStatistics & statistics
713 #endif
714 #if ABC_PARALLEL
715 ,int whichSparse=0
716 #endif
717 ) const;
718
720 void updateColumnUSparse ( CoinIndexedVector * regionSparse
721 #if ABC_PARALLEL
722 ,int whichSparse
723 #endif
724 ) const;
726 void updateColumnUDensish ( CoinIndexedVector * regionSparse) const;
728 void updateColumnUDense ( CoinIndexedVector * regionSparse) const;
730 void updateTwoColumnsUDensish (
731 CoinSimplexInt & numberNonZero1,
732 CoinFactorizationDouble * COIN_RESTRICT region1,
733 CoinSimplexInt * COIN_RESTRICT index1,
734 CoinSimplexInt & numberNonZero2,
735 CoinFactorizationDouble * COIN_RESTRICT region2,
736 CoinSimplexInt * COIN_RESTRICT index2) const;
738 void updateColumnPFI ( CoinIndexedVector * regionSparse) const;
740 void updateColumnTransposePFI ( CoinIndexedVector * region) const;
743 void updateColumnTransposeU ( CoinIndexedVector * region,
744 CoinSimplexInt smallestIndex
745 #if ABC_SMALL<2
746 , CoinAbcStatistics & statistics
747 #endif
748 #if ABC_PARALLEL
749 ,int whichCpu
750 #endif
751 ) const;
754 void updateColumnTransposeUDensish ( CoinIndexedVector * region,
755 CoinSimplexInt smallestIndex) const;
758 void updateColumnTransposeUSparse ( CoinIndexedVector * region
759 #if ABC_PARALLEL
760 ,int whichSparse
761 #endif
762 ) const;
765 void updateColumnTransposeUByColumn ( CoinIndexedVector * region,
766 CoinSimplexInt smallestIndex) const;
767
769 void updateColumnTransposeR ( CoinIndexedVector * region
770 #if ABC_SMALL<2
771 , CoinAbcStatistics & statistics
772 #endif
773 ) const;
775 void updateColumnTransposeRDensish ( CoinIndexedVector * region ) const;
777 void updateColumnTransposeRSparse ( CoinIndexedVector * region ) const;
778
780 void updateColumnTransposeL ( CoinIndexedVector * region
781 #if ABC_SMALL<2
782 , CoinAbcStatistics & statistics
783 #endif
784 #if ABC_PARALLEL
785 ,int whichSparse
786 #endif
787 ) const;
789 void updateColumnTransposeLDensish ( CoinIndexedVector * region ) const;
791 void updateColumnTransposeLByRow ( CoinIndexedVector * region ) const;
793 void updateColumnTransposeLSparse ( CoinIndexedVector * region
794 #if ABC_PARALLEL
795 ,int whichSparse
796 #endif
797 ) const;
798 public:
803 CoinSimplexInt replaceColumnPFI ( CoinIndexedVector * regionSparse,
804 CoinSimplexInt pivotRow, CoinSimplexDouble alpha);
805 protected:
808 CoinSimplexInt checkPivot(CoinSimplexDouble saveFromU, CoinSimplexDouble oldPivot) const;
810 int pivot ( CoinSimplexInt pivotRow,
811 CoinSimplexInt pivotColumn,
812 CoinBigIndex pivotRowPosition,
813 CoinBigIndex pivotColumnPosition,
814 CoinFactorizationDouble * COIN_RESTRICT work,
815 CoinSimplexUnsignedInt * COIN_RESTRICT workArea2,
816 CoinSimplexInt increment2,
817 int * COIN_RESTRICT markRow );
818 int pivot ( CoinSimplexInt & pivotRow,
819 CoinSimplexInt & pivotColumn,
820 CoinBigIndex pivotRowPosition,
821 CoinBigIndex pivotColumnPosition,
822 int * COIN_RESTRICT markRow );
823 #if ABC_SMALL<2
824 #define CONVERTROW 2
825 #elif ABC_SMALL<4
826 #else
827 #undef ABC_DENSE_CODE
828 #define ABC_DENSE_CODE 0
829 #endif
830
832 protected:
834
837 CoinSimplexInt * pivotColumnAddress_;
838 CoinSimplexInt * permuteAddress_;
839 CoinFactorizationDouble * pivotRegionAddress_;
840 CoinFactorizationDouble * elementUAddress_;
841 CoinSimplexInt * indexRowUAddress_;
842 CoinSimplexInt * numberInColumnAddress_;
843 CoinSimplexInt * numberInColumnPlusAddress_;
844 #ifdef ABC_USE_FUNCTION_POINTERS
845 scatterStruct * scatterPointersUColumnAddress_;
847 CoinFactorizationDouble * elementUColumnPlusAddress_;
848 #endif
849 CoinBigIndex * startColumnUAddress_;
850 #if CONVERTROW
851 CoinBigIndex * convertRowToColumnUAddress_;
852 #if CONVERTROW>1
853 CoinBigIndex * convertColumnToRowUAddress_;
854 #endif
855 #endif
856 #if ABC_SMALL<2
857 CoinFactorizationDouble * elementRowUAddress_;
858 #endif
859 CoinBigIndex * startRowUAddress_;
860 CoinSimplexInt * numberInRowAddress_;
861 CoinSimplexInt * indexColumnUAddress_;
862 CoinSimplexInt * firstCountAddress_;
864 CoinSimplexInt * nextCountAddress_;
866 CoinSimplexInt * lastCountAddress_;
867 CoinSimplexInt * nextColumnAddress_;
868 CoinSimplexInt * lastColumnAddress_;
869 CoinSimplexInt * nextRowAddress_;
870 CoinSimplexInt * lastRowAddress_;
871 CoinSimplexInt * saveColumnAddress_;
872 //CoinSimplexInt * saveColumnAddress2_;
873 CoinCheckZero * markRowAddress_;
874 CoinSimplexInt * listAddress_;
875 CoinFactorizationDouble * elementLAddress_;
876 CoinSimplexInt * indexRowLAddress_;
877 CoinBigIndex * startColumnLAddress_;
878 #if ABC_SMALL<2
879 CoinBigIndex * startRowLAddress_;
880 #endif
881 CoinSimplexInt * pivotLinkedBackwardsAddress_;
882 CoinSimplexInt * pivotLinkedForwardsAddress_;
883 CoinSimplexInt * pivotLOrderAddress_;
884 CoinBigIndex * startColumnRAddress_;
886 CoinFactorizationDouble *elementRAddress_;
888 CoinSimplexInt *indexRowRAddress_;
889 CoinSimplexInt * indexColumnLAddress_;
890 CoinFactorizationDouble * elementByRowLAddress_;
891 #if ABC_SMALL<4
892 CoinFactorizationDouble * denseAreaAddress_;
893 #endif
894 CoinFactorizationDouble * workAreaAddress_;
895 CoinSimplexUnsignedInt * workArea2Address_;
896 mutable CoinSimplexInt * sparseAddress_;
897 #ifdef SMALL_PERMUTE
898 CoinSimplexInt * fromSmallToBigRow_;
899 CoinSimplexInt * fromSmallToBigColumn_;
900 #endif
901 CoinSimplexInt numberRowsExtra_;
904 CoinSimplexInt maximumRowsExtra_;
906 CoinSimplexInt numberRowsSmall_;
908 CoinSimplexInt numberGoodL_;
910 CoinSimplexInt numberRowsLeft_;
913 CoinBigIndex totalElements_;
915 CoinBigIndex firstZeroed_;
916 #if ABC_SMALL<2
917 CoinSimplexInt sparseThreshold_;
919 #endif
920 CoinSimplexInt numberR_;
923 CoinBigIndex lengthR_;
925 CoinBigIndex lengthAreaR_;
927 CoinBigIndex numberL_;
929 CoinBigIndex baseL_;
931 CoinBigIndex lengthL_;
933 CoinBigIndex lengthAreaL_;
935 CoinSimplexInt numberU_;
937 CoinBigIndex maximumU_;
939 CoinBigIndex lengthU_;
941 CoinBigIndex lengthAreaU_;
943 CoinBigIndex lastEntryByColumnU_;
944 #ifdef ABC_USE_FUNCTION_POINTERS
945 CoinBigIndex lastEntryByColumnUPlus_;
948 CoinBigIndex lengthAreaUPlus_;
949 #endif
950 CoinBigIndex lastEntryByRowU_;
953 CoinSimplexInt numberTrials_;
954 #if ABC_SMALL<4
955 CoinSimplexInt leadingDimension_;
957 #endif
958 #if COIN_BIG_DOUBLE==1
959 mutable CoinFactorizationLongDoubleArrayWithLength longArray_[FACTOR_CPU];
962 mutable CoinIndexedVector * associatedVector_[FACTOR_CPU];
963 #endif
964 CoinIntArrayWithLength pivotColumn_;
967 CoinIntArrayWithLength permute_;
969 CoinBigIndexArrayWithLength startRowU_;
971 CoinIntArrayWithLength numberInRow_;
973 CoinIntArrayWithLength numberInColumn_;
975 CoinIntArrayWithLength numberInColumnPlus_;
978 CoinIntArrayWithLength firstCount_;
980 CoinIntArrayWithLength nextColumn_;
982 CoinIntArrayWithLength lastColumn_;
984 CoinIntArrayWithLength nextRow_;
986 CoinIntArrayWithLength lastRow_;
988 CoinIntArrayWithLength saveColumn_;
990 CoinIntArrayWithLength markRow_;
992 CoinIntArrayWithLength indexColumnU_;
994 CoinFactorizationDoubleArrayWithLength pivotRegion_;
996 CoinFactorizationDoubleArrayWithLength elementU_;
998 CoinIntArrayWithLength indexRowU_;
1000 CoinBigIndexArrayWithLength startColumnU_;
1001 #ifdef ABC_USE_FUNCTION_POINTERS
1002 CoinArbitraryArrayWithLength scatterUColumn_;
1004 #endif
1005 #if CONVERTROW
1006 CoinBigIndexArrayWithLength convertRowToColumnU_;
1008 #if CONVERTROW>1
1009 CoinBigIndexArrayWithLength convertColumnToRowU_;
1011 #endif
1012 #endif
1013 #if ABC_SMALL<2
1014 CoinFactorizationDoubleArrayWithLength elementRowU_;
1016 #endif
1017 CoinFactorizationDoubleArrayWithLength elementL_;
1020 CoinIntArrayWithLength indexRowL_;
1022 CoinBigIndexArrayWithLength startColumnL_;
1023 #if ABC_SMALL<4
1024 CoinFactorizationDoubleArrayWithLength denseArea_;
1026 #endif
1027 CoinFactorizationDoubleArrayWithLength workArea_;
1030 CoinUnsignedIntArrayWithLength workArea2_;
1031 #if ABC_SMALL<2
1032 CoinBigIndexArrayWithLength startRowL_;
1035 CoinIntArrayWithLength indexColumnL_;
1037 CoinFactorizationDoubleArrayWithLength elementByRowL_;
1039 mutable CoinIntArrayWithLength sparse_;
1040 #endif
1041 CoinSimplexInt messageLevel_;
1044 CoinBigIndex numberCompressions_;
1045 // last slack pivot row
1046 CoinSimplexInt lastSlack_;
1047 #if ABC_SMALL<2
1048 mutable double ftranCountInput_;
1050 mutable double ftranCountAfterL_;
1051 mutable double ftranCountAfterR_;
1052 mutable double ftranCountAfterU_;
1053 double ftranAverageAfterL_;
1054 double ftranAverageAfterR_;
1055 double ftranAverageAfterU_;
1056 #if FACTORIZATION_STATISTICS
1057 double ftranTwiddleFactor1_;
1058 double ftranTwiddleFactor2_;
1059 #endif
1060 mutable CoinSimplexInt numberFtranCounts_;
1061 #endif
1062 CoinSimplexInt maximumRows_;
1064 #if ABC_SMALL<2
1065 mutable double ftranFTCountInput_;
1066 mutable double ftranFTCountAfterL_;
1067 mutable double ftranFTCountAfterR_;
1068 mutable double ftranFTCountAfterU_;
1069 double ftranFTAverageAfterL_;
1070 double ftranFTAverageAfterR_;
1071 double ftranFTAverageAfterU_;
1072 #if FACTORIZATION_STATISTICS
1073 double ftranFTTwiddleFactor1_;
1074 double ftranFTTwiddleFactor2_;
1075 #endif
1076 mutable CoinSimplexInt numberFtranFTCounts_;
1077 #endif
1078 #if ABC_SMALL<4
1079 CoinSimplexInt denseThreshold_;
1081 #endif
1082 #if ABC_SMALL<2
1083 mutable double btranCountInput_;
1084 mutable double btranCountAfterU_;
1085 mutable double btranCountAfterR_;
1086 mutable double btranCountAfterL_;
1087 double btranAverageAfterU_;
1088 double btranAverageAfterR_;
1089 double btranAverageAfterL_;
1090 #if FACTORIZATION_STATISTICS
1091 double btranTwiddleFactor1_;
1092 double btranTwiddleFactor2_;
1093 #endif
1094 mutable CoinSimplexInt numberBtranCounts_;
1095 #endif
1096 CoinSimplexInt maximumMaximumPivots_;
1098 #if ABC_SMALL<2
1099 mutable double ftranFullCountInput_;
1101 mutable double ftranFullCountAfterL_;
1102 mutable double ftranFullCountAfterR_;
1103 mutable double ftranFullCountAfterU_;
1104 double ftranFullAverageAfterL_;
1105 double ftranFullAverageAfterR_;
1106 double ftranFullAverageAfterU_;
1107 #if FACTORIZATION_STATISTICS
1108 double ftranFullTwiddleFactor1_;
1109 double ftranFullTwiddleFactor2_;
1110 #endif
1111 mutable CoinSimplexInt numberFtranFullCounts_;
1112 #endif
1113 CoinSimplexInt initialNumberRows_;
1115 #if ABC_SMALL<2
1116 mutable double btranFullCountInput_;
1118 mutable double btranFullCountAfterL_;
1119 mutable double btranFullCountAfterR_;
1120 mutable double btranFullCountAfterU_;
1121 double btranFullAverageAfterL_;
1122 double btranFullAverageAfterR_;
1123 double btranFullAverageAfterU_;
1124 #if FACTORIZATION_STATISTICS
1125 double btranFullTwiddleFactor1_;
1126 double btranFullTwiddleFactor2_;
1127 #endif
1128 mutable CoinSimplexInt numberBtranFullCounts_;
1129 #endif
1130
1136 CoinSimplexInt state_;
1138 CoinBigIndex sizeSparseArray_;
1139 public:
1140 #if ABC_SMALL<2
1141 #if ABC_SMALL>=0
1142 inline bool gotLCopy() const {return ((state_&ABC_FAC_GOT_LCOPY)!=0);}
1143 inline void setNoGotLCopy() {state_ &= ~ABC_FAC_GOT_LCOPY;}
1144 inline void setYesGotLCopy() {state_ |= ABC_FAC_GOT_LCOPY;}
1145 inline bool gotRCopy() const {return ((state_&ABC_FAC_GOT_RCOPY)!=0);}
1146 inline void setNoGotRCopy() {state_ &= ~ABC_FAC_GOT_RCOPY;}
1147 inline void setYesGotRCopy() {state_ |= ABC_FAC_GOT_RCOPY;}
1148 inline bool gotUCopy() const {return ((state_&ABC_FAC_GOT_UCOPY)!=0);}
1149 inline void setNoGotUCopy() {state_ &= ~ABC_FAC_GOT_UCOPY;}
1150 inline void setYesGotUCopy() {state_ |= ABC_FAC_GOT_UCOPY;}
1151 inline bool gotSparse() const {return ((state_&ABC_FAC_GOT_SPARSE)!=0);}
1152 inline void setNoGotSparse() {state_ &= ~ABC_FAC_GOT_SPARSE;}
1153 inline void setYesGotSparse() {state_ |= ABC_FAC_GOT_SPARSE;}
1154 #else
1155 // force use of copies
1156 inline bool gotLCopy() const {return true;}
1157 inline void setNoGotLCopy() {}
1158 inline void setYesGotLCopy() {}
1159 inline bool gotRCopy() const {return true;}
1160 inline void setNoGotRCopy() {}
1161 inline void setYesGotRCopy() {}
1162 inline bool gotUCopy() const {return true;}
1163 inline void setNoGotUCopy() {}
1164 inline void setYesGotUCopy() {}
1165 inline bool gotSparse() const {return true;}
1166 inline void setNoGotSparse() {}
1167 inline void setYesGotSparse() {}
1168 #endif
1169 #else
1170 // force no use of copies
1171 inline bool gotLCopy() const {return false;}
1172 inline void setNoGotLCopy() {}
1173 inline void setYesGotLCopy() {}
1174 inline bool gotRCopy() const {return false;}
1175 inline void setNoGotRCopy() {}
1176 inline void setYesGotRCopy() {}
1177 inline bool gotUCopy() const {return false;}
1178 inline void setNoGotUCopy() {}
1179 inline void setYesGotUCopy() {}
1180 inline bool gotSparse() const {return false;}
1181 inline void setNoGotSparse() {}
1182 inline void setYesGotSparse() {}
1183 #endif
1184
1189 //CoinSimplexInt persistenceFlag_;
1191 };
1192
1193
CoinAbcTypeFactorization::numberL_
CoinBigIndex numberL_
Number in L.
Definition: CoinAbcBaseFactorization.hpp:927
CoinBigIndexArrayWithLength::array
CoinBigIndex * array() const
Get Array.
Definition: CoinIndexedVector.hpp:844
CoinUnsignedIntArrayWithLength
unsigned int * version
Definition: CoinIndexedVector.hpp:889
CoinAbcTypeFactorization::btranAverageAfterL_
double btranAverageAfterL_
Definition: CoinAbcBaseFactorization.hpp:1089
CoinAbcTypeFactorization::ftranFTCountAfterU_
double ftranFTCountAfterU_
Definition: CoinAbcBaseFactorization.hpp:1068
CoinAbcTypeFactorization::updateColumnTransposeRDensish
void updateColumnTransposeRDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when dense.
CoinAbcTypeFactorization::lastRow_
CoinIntArrayWithLength lastRow_
Previous Row in memory order.
Definition: CoinAbcBaseFactorization.hpp:986
CoinAbcTypeFactorization::startRowL_
CoinBigIndexArrayWithLength startRowL_
Start of each row in L.
Definition: CoinAbcBaseFactorization.hpp:1033
CoinAbcTypeFactorization::ftranAverageAfterL_
double ftranAverageAfterL_
Definition: CoinAbcBaseFactorization.hpp:1053
CoinAbcTypeFactorization::gutsOfInitialize
void gutsOfInitialize(CoinSimplexInt type)
1 bit - tolerances etc, 2 more, 4 dummy arrays
CoinAbcTypeFactorization::setYesGotRCopy
void setYesGotRCopy()
Definition: CoinAbcBaseFactorization.hpp:1147
CoinAbcTypeFactorization::updateColumnTransposeUSparse
void updateColumnTransposeUSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANU) when sparse, assumes index is sorted i.e.
CoinAbcTypeFactorization::ftranFTCountAfterR_
double ftranFTCountAfterR_
Definition: CoinAbcBaseFactorization.hpp:1067
CoinAbcAnyFactorization::numberRows_
int numberRows_
Number of Rows in factorization.
Definition: CoinAbcDenseFactorization.hpp:351
CoinAbcTypeFactorization::startColumnR
CoinBigIndex * startColumnR() const
Start of columns for R.
Definition: CoinAbcBaseFactorization.hpp:262
CoinAbcTypeFactorization::indexRowL_
CoinIntArrayWithLength indexRowL_
Row indices of L.
Definition: CoinAbcBaseFactorization.hpp:1020
CoinAbcTypeFactorization::startColumnLAddress_
CoinBigIndex * startColumnLAddress_
Definition: CoinAbcBaseFactorization.hpp:877
CoinAbcTypeFactorization::maximumMaximumPivots_
CoinSimplexInt maximumMaximumPivots_
Maximum maximum pivots.
Definition: CoinAbcBaseFactorization.hpp:1097
CoinAbcTypeFactorization::btranFullCountAfterU_
double btranFullCountAfterU_
Definition: CoinAbcBaseFactorization.hpp:1120
CoinAbcTypeFactorization::nextColumnAddress_
CoinSimplexInt * nextColumnAddress_
Definition: CoinAbcBaseFactorization.hpp:867
CoinAbcTypeFactorization::denseVector
double * denseVector(CoinIndexedVector &vector) const
Definition: CoinAbcBaseFactorization.hpp:296
CoinAbcTypeFactorization::updatePartialUpdate
void updatePartialUpdate(CoinIndexedVector &partialUpdate)
Update partial Ftran by R update.
CoinAbcTypeFactorization::numberFtranFullCounts_
CoinSimplexInt numberFtranFullCounts_
Definition: CoinAbcBaseFactorization.hpp:1111
CoinAbcTypeFactorization::numberGoodL_
CoinSimplexInt numberGoodL_
Number factorized in L.
Definition: CoinAbcBaseFactorization.hpp:908
CoinAbcTypeFactorization::getAreas
virtual void getAreas(CoinSimplexInt numberRows, CoinSimplexInt numberColumns, CoinBigIndex maximumL, CoinBigIndex maximumU)
Gets space for a factorization, called by constructors.
CoinAbcTypeFactorization::indexColumnL
CoinSimplexInt * indexColumnL() const
Index of column in row for L.
Definition: CoinAbcBaseFactorization.hpp:94
CoinAbcTypeFactorization::setDenseThreshold
void setDenseThreshold(CoinSimplexInt value)
Sets dense threshold.
Definition: CoinAbcBaseFactorization.hpp:192
CoinAbcTypeFactorization::pivotRegion_
CoinFactorizationDoubleArrayWithLength pivotRegion_
Inverses of pivot values.
Definition: CoinAbcBaseFactorization.hpp:994
CoinAbcTypeFactorization::checkReplacePart2
virtual int checkReplacePart2(int pivotRow, CoinSimplexDouble btranAlpha, double ftranAlpha, double ftAlpha, double acceptablePivot=1.0e-8)
Checks if can replace one Column to basis, returns 0=OK, 1=Probably OK, 2=singular, 3=no room, 5 max pivots.
CoinAbcTypeFactorization::maximumRowsExtra_
CoinSimplexInt maximumRowsExtra_
Maximum number of Rows after iterating.
Definition: CoinAbcBaseFactorization.hpp:904
CoinAbcTypeFactorization::numberElementsL
CoinBigIndex numberElementsL() const
Returns number in L area.
Definition: CoinAbcBaseFactorization.hpp:229
CoinAbcTypeFactorization::numberRowsExtra_
CoinSimplexInt numberRowsExtra_
Number of Rows after iterating.
Definition: CoinAbcBaseFactorization.hpp:902
CoinAbcTypeFactorization::denseThreshold_
CoinSimplexInt denseThreshold_
Dense threshold (here to use double alignment)
Definition: CoinAbcBaseFactorization.hpp:1080
CoinAbcTypeFactorization::CoinAbcTypeFactorization
CoinAbcTypeFactorization()
Default constructor.
CoinAbcTypeFactorization::updateColumnTransposeL
void updateColumnTransposeL(CoinIndexedVector *region, CoinAbcStatistics &statistics) const
Updates part of column transpose (BTRANL)
CoinAbcTypeFactorization::btranFullCountAfterR_
double btranFullCountAfterR_
Definition: CoinAbcBaseFactorization.hpp:1119
CoinAbcTypeFactorization::indexColumnLAddress_
CoinSimplexInt * indexColumnLAddress_
Definition: CoinAbcBaseFactorization.hpp:889
CoinAbcTypeFactorization::checkMarkArrays
virtual void checkMarkArrays() const
ABC_PARALLEL
#define ABC_PARALLEL
Definition: CoinAbcCommon.hpp:36
CoinAbcTypeFactorization::firstCount_
CoinIntArrayWithLength firstCount_
First Row/Column with count of k, can tell which by offset - Rows then Columns.
Definition: CoinAbcBaseFactorization.hpp:978
CoinAbcTypeFactorization::startRowLAddress_
CoinBigIndex * startRowLAddress_
Definition: CoinAbcBaseFactorization.hpp:879
CoinAbcTypeFactorization::sizeSparseArray_
CoinBigIndex sizeSparseArray_
Size in bytes of a sparseArray.
Definition: CoinAbcBaseFactorization.hpp:1138
AbcSimplex
Definition: AbcSimplex.hpp:62
CoinAbcTypeFactorization::ftranFullCountAfterU_
double ftranFullCountAfterU_
Definition: CoinAbcBaseFactorization.hpp:1103
CoinAbcTypeFactorization::clone
virtual CoinAbcAnyFactorization * clone() const
Clone.
CoinAbcTypeFactorization::goSparse2
void goSparse2()
CoinAbcTypeFactorization::markRow_
CoinIntArrayWithLength markRow_
Marks rows to be updated.
Definition: CoinAbcBaseFactorization.hpp:990
CoinAbcTypeFactorization::fromLongArray
void fromLongArray(CoinIndexedVector *vector) const
From a work array and dis-associate vector.
Definition: CoinAbcBaseFactorization.hpp:306
CoinAbcTypeFactorization::ftranFTAverageAfterL_
double ftranFTAverageAfterL_
Definition: CoinAbcBaseFactorization.hpp:1069
CoinAbcTypeFactorization::lastColumn_
CoinIntArrayWithLength lastColumn_
Previous Column in memory order.
Definition: CoinAbcBaseFactorization.hpp:982
CoinAbcTypeFactorization::deleteLink
void deleteLink(CoinSimplexInt index)
Deletes a link in chain of equal counts.
Definition: CoinAbcBaseFactorization.hpp:623
CoinAbcTypeFactorization::numberTrials_
CoinSimplexInt numberTrials_
Number of trials before rejection.
Definition: CoinAbcBaseFactorization.hpp:953
CoinAbcTypeFactorization::replaceColumnPFI
CoinSimplexInt replaceColumnPFI(CoinIndexedVector *regionSparse, CoinSimplexInt pivotRow, CoinSimplexDouble alpha)
Replaces one Column to basis for PFI returns 0=OK, 1=Probably OK, 2=singular, 3=no room...
void
typedef void(COINLINKAGE_CB *clp_callback)(Clp_Simplex *model
typedef for user call back.
CoinAbcTypeFactorization::numberInColumnAddress_
CoinSimplexInt * numberInColumnAddress_
Definition: CoinAbcBaseFactorization.hpp:842
CoinAbcTypeFactorization::setNumberElementsU
void setNumberElementsU(CoinBigIndex value)
Setss number in U area.
Definition: CoinAbcBaseFactorization.hpp:222
CoinAbcTypeFactorization::lengthL_
CoinBigIndex lengthL_
Length of L.
Definition: CoinAbcBaseFactorization.hpp:931
CoinAbcTypeFactorization::elementRowU_
CoinFactorizationDoubleArrayWithLength elementRowU_
Elements of U by row.
Definition: CoinAbcBaseFactorization.hpp:1015
CoinAbcTypeFactorization::indexColumnU_
CoinIntArrayWithLength indexColumnU_
Base address for U (may change)
Definition: CoinAbcBaseFactorization.hpp:992
CoinAbcTypeFactorization::lastCount
CoinSimplexInt * lastCount() const
Previous Row/Column with count.
Definition: CoinAbcBaseFactorization.hpp:151
CoinAbcTypeFactorization::elementUAddress_
CoinFactorizationDouble * elementUAddress_
Definition: CoinAbcBaseFactorization.hpp:840
CoinAbcTypeFactorization::updateTwoColumnsUDensish
void updateTwoColumnsUDensish(CoinSimplexInt &numberNonZero1, CoinFactorizationDouble *COIN_RESTRICT region1, CoinSimplexInt *COIN_RESTRICT index1, CoinSimplexInt &numberNonZero2, CoinFactorizationDouble *COIN_RESTRICT region2, CoinSimplexInt *COIN_RESTRICT index2) const
Updates part of 2 columns (FTRANU) real work.
CoinAbcTypeFactorization::elementU
CoinFactorizationDouble * elementU() const
Elements of U.
Definition: CoinAbcBaseFactorization.hpp:265
CoinAbcTypeFactorization::firstZeroed_
CoinBigIndex firstZeroed_
First place in funny copy zeroed out.
Definition: CoinAbcBaseFactorization.hpp:915
CoinAbcAnyFactorization
Abstract base class which also has some scalars so can be used from Dense or Simp.
Definition: CoinAbcDenseFactorization.hpp:24
ABC_FAC_GOT_SPARSE
#define ABC_FAC_GOT_SPARSE
Definition: CoinAbcCommonFactorization.hpp:70
CoinAbcTypeFactorization::getRowSpaceIterate
bool getRowSpaceIterate(CoinSimplexInt iRow, CoinSimplexInt extraNeeded)
Gets space for one Row with given length while iterating, may have to do compression (returns True i...
CoinAbcTypeFactorization::startRowUAddress_
CoinBigIndex * startRowUAddress_
Definition: CoinAbcBaseFactorization.hpp:859
CoinAbcTypeFactorization::addLink
void addLink(CoinSimplexInt index, CoinSimplexInt count)
Adds a link in chain of equal counts.
Definition: CoinAbcBaseFactorization.hpp:611
CoinAbcTypeFactorization::CoinAbcFactorizationUnitTest
friend void CoinAbcFactorizationUnitTest(const std::string &mpsDir)
CoinAbcTypeFactorization::firstCountAddress_
CoinSimplexInt * firstCountAddress_
Definition: CoinAbcBaseFactorization.hpp:862
CoinAbcTypeFactorization::gotSparse
bool gotSparse() const
Definition: CoinAbcBaseFactorization.hpp:1151
CoinAbcTypeFactorization::updateColumnUDensish
void updateColumnUDensish(CoinIndexedVector *regionSparse) const
Updates part of column (FTRANU)
CoinAbcTypeFactorization::preProcess3
double preProcess3()
Return largest element.
CoinAbcTypeFactorization::numberBtranCounts_
CoinSimplexInt numberBtranCounts_
Definition: CoinAbcBaseFactorization.hpp:1094
CoinAbcTypeFactorization::setYesGotSparse
void setYesGotSparse()
Definition: CoinAbcBaseFactorization.hpp:1153
CoinAbcTypeFactorization::btranCountAfterL_
double btranCountAfterL_
Definition: CoinAbcBaseFactorization.hpp:1086
CoinAbcTypeFactorization::lastCountAddress_
CoinSimplexInt * lastCountAddress_
Previous Row/Column with count.
Definition: CoinAbcBaseFactorization.hpp:866
CoinAbcTypeFactorization::lengthAreaR_
CoinBigIndex lengthAreaR_
length of area reserved for R
Definition: CoinAbcBaseFactorization.hpp:925
CoinAbcTypeFactorization::factor
virtual CoinSimplexInt factor(AbcSimplex *model)
Does most of factorization.
CoinAbcTypeFactorization::numberInRow_
CoinIntArrayWithLength numberInRow_
Number in each Row.
Definition: CoinAbcBaseFactorization.hpp:971
CoinAbcTypeFactorization::checkConsistency
void checkConsistency()
Checks that row and column copies look OK.
CoinAbcHelperFunctions.hpp
CoinAbcTypeFactorization::baseL
CoinBigIndex baseL() const
Base of L.
Definition: CoinAbcBaseFactorization.hpp:163
CoinAbcTypeFactorization::pivotLinkedForwards
CoinSimplexInt * pivotLinkedForwards() const
Definition: CoinAbcBaseFactorization.hpp:112
CoinAbcTypeFactorization::btranFullCountAfterL_
double btranFullCountAfterL_
Definition: CoinAbcBaseFactorization.hpp:1118
CoinAbcTypeFactorization::btranCountAfterR_
double btranCountAfterR_
Definition: CoinAbcBaseFactorization.hpp:1085
CoinAbcTypeFactorization::numberInRow
virtual CoinSimplexInt * numberInRow() const
Number of entries in each row.
Definition: CoinAbcBaseFactorization.hpp:253
CoinAbcTypeFactorization::denseVector
const double * denseVector(const CoinIndexedVector &vector) const
Definition: CoinAbcBaseFactorization.hpp:301
CoinAbcTypeFactorization::separateLinks
void separateLinks()
Separate out links with same row/column count.
CoinAbcTypeFactorization::ftranCountAfterU_
double ftranCountAfterU_
Definition: CoinAbcBaseFactorization.hpp:1052
CoinAbcTypeFactorization::updateColumnTransposeR
void updateColumnTransposeR(CoinIndexedVector *region, CoinAbcStatistics &statistics) const
Updates part of column transpose (BTRANR)
CoinAbcTypeFactorization::startColumnU_
CoinBigIndexArrayWithLength startColumnU_
Start of each column in U.
Definition: CoinAbcBaseFactorization.hpp:1000
checkLinks
#define checkLinks(x)
Definition: CoinAbcBaseFactorization.hpp:608
CoinAbcTypeFactorization::convertColumnToRowUAddress_
CoinBigIndex * convertColumnToRowUAddress_
Definition: CoinAbcBaseFactorization.hpp:853
CoinIndexedVector::denseVector
double * denseVector() const
Get the vector as a dense vector.
Definition: CoinIndexedVector.hpp:121
CoinAbcTypeFactorization::startColumnL
CoinBigIndex * startColumnL() const
Start of each column in L.
Definition: CoinAbcBaseFactorization.hpp:89
CoinAbcAnyFactorization::numberRows
int numberRows() const
Number of Rows after factorization.
Definition: CoinAbcDenseFactorization.hpp:76
CoinAbcTypeFactorization::pivotRowSingleton
bool pivotRowSingleton(CoinSimplexInt pivotRow, CoinSimplexInt pivotColumn)
Does one pivot on Row Singleton in factorization.
CoinAbcTypeFactorization::setYesGotLCopy
void setYesGotLCopy()
Definition: CoinAbcBaseFactorization.hpp:1144
CoinAbcTypeFactorization::updateColumnTransposeLDensish
void updateColumnTransposeLDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by column.
CoinAbcTypeFactorization::updateColumnTransposeCpu
virtual void updateColumnTransposeCpu(CoinIndexedVector &regionSparse, int whichCpu) const
Updates one column (BTRAN)
CoinAbcTypeFactorization::factorDense
CoinSimplexInt factorDense()
Does dense phase of factorization return code is &lt;0 error, 0= finished.
CoinAbcTypeFactorization::sparseAddress_
CoinSimplexInt * sparseAddress_
Definition: CoinAbcBaseFactorization.hpp:896
CoinAbcTypeFactorization::updateColumnFTPart2
virtual void updateColumnFTPart2(CoinIndexedVector &regionSparse)
CoinAbcTypeFactorization::lengthR_
CoinBigIndex lengthR_
Length of R stuff.
Definition: CoinAbcBaseFactorization.hpp:923
CoinAbcTypeFactorization::ftranFullAverageAfterU_
double ftranFullAverageAfterU_
Definition: CoinAbcBaseFactorization.hpp:1106
CoinAbcTypeFactorization::updateWeights
virtual void updateWeights(CoinIndexedVector &regionSparse) const
Updates one column for dual steepest edge weights (FTRAN)
CoinAbcTypeFactorization::checkSparse
void checkSparse()
See if worth going sparse.
CoinAbcTypeFactorization::doAddresses
void doAddresses()
Set up addresses from arrays.
CoinAbcTypeFactorization::spaceForForrestTomlin
bool spaceForForrestTomlin() const
True if FT update and space.
Definition: CoinAbcBaseFactorization.hpp:205
CoinAbcTypeFactorization::pivotColumnSingleton
void pivotColumnSingleton(CoinSimplexInt pivotRow, CoinSimplexInt pivotColumn)
Does one pivot on Column Singleton in factorization (can&#39;t return false)
CoinAbcTypeFactorization::ftranAverageAfterR_
double ftranAverageAfterR_
Definition: CoinAbcBaseFactorization.hpp:1054
CoinAbcTypeFactorization::numberInColumnPlus_
CoinIntArrayWithLength numberInColumnPlus_
Number in each Column including pivoted.
Definition: CoinAbcBaseFactorization.hpp:975
CoinAbcTypeFactorization::startColumnU
CoinBigIndex * startColumnU() const
Start of each column in U.
Definition: CoinAbcBaseFactorization.hpp:271
CoinAbcTypeFactorization::preProcess4
void preProcess4()
CoinAbcTypeFactorization::ftranFullCountAfterL_
double ftranFullCountAfterL_
Definition: CoinAbcBaseFactorization.hpp:1101
CoinAbcTypeFactorization::messageLevel
CoinSimplexInt messageLevel() const
Level of detail of messages.
Definition: CoinAbcBaseFactorization.hpp:180
CoinAbcTypeFactorization::lastSlack_
CoinSimplexInt lastSlack_
Definition: CoinAbcBaseFactorization.hpp:1046
CoinAbcTypeFactorization::startRowL
CoinBigIndex * startRowL() const
Start of each row in L.
Definition: CoinAbcBaseFactorization.hpp:84
CoinAbcTypeFactorization::afterPivot
void afterPivot(CoinSimplexInt pivotRow, CoinSimplexInt pivotColumn)
After pivoting.
CoinAbcTypeFactorization::numberForrestTomlin
CoinSimplexInt numberForrestTomlin() const
Length of FT vector.
Definition: CoinAbcBaseFactorization.hpp:174
CoinAbcTypeFactorization::ftranFullAverageAfterL_
double ftranFullAverageAfterL_
Definition: CoinAbcBaseFactorization.hpp:1104
CoinAbcTypeFactorization::numberU_
CoinSimplexInt numberU_
Number in U.
Definition: CoinAbcBaseFactorization.hpp:935
CoinAbcTypeFactorization::ftranAverageAfterU_
double ftranAverageAfterU_
Definition: CoinAbcBaseFactorization.hpp:1055
CoinAbcTypeFactorization::leadingDimension_
CoinSimplexInt leadingDimension_
Leading dimension for dense.
Definition: CoinAbcBaseFactorization.hpp:956
CoinAbcTypeFactorization::preProcess
virtual void preProcess()
PreProcesses column ordered copy of basis.
CoinAbcTypeFactorization::numberRowsSmall_
CoinSimplexInt numberRowsSmall_
Size of small inverse.
Definition: CoinAbcBaseFactorization.hpp:906
CoinAbcTypeFactorization::btranAverageAfterR_
double btranAverageAfterR_
Definition: CoinAbcBaseFactorization.hpp:1088
CoinAbcTypeFactorization::reorderU
bool reorderU()
Reorders U so contiguous and in order (if there is space) Returns true if it could.
CoinAbcTypeFactorization::pivotLinkedBackwards
CoinSimplexInt * pivotLinkedBackwards() const
Forward and backward linked lists (numberRows_+2)
Definition: CoinAbcBaseFactorization.hpp:110
CoinAbcAnyFactorization::pivotRow
virtual int * pivotRow() const
Returns pivot row.
COIN_RESTRICT
#define COIN_RESTRICT
Definition: ClpMatrixBase.hpp:21
CoinAbcTypeFactorization::elementL_
CoinFactorizationDoubleArrayWithLength elementL_
Elements of L.
Definition: CoinAbcBaseFactorization.hpp:1018
CoinAbcTypeFactorization::numberFtranCounts_
CoinSimplexInt numberFtranCounts_
Definition: CoinAbcBaseFactorization.hpp:1060
CoinAbcTypeFactorization::ftranFTCountAfterL_
double ftranFTCountAfterL_
Definition: CoinAbcBaseFactorization.hpp:1066
CoinAbcTypeFactorization::pivotRegionAddress_
CoinFactorizationDouble * pivotRegionAddress_
Definition: CoinAbcBaseFactorization.hpp:839
CoinAbcTypeFactorization::lengthAreaL
CoinBigIndex lengthAreaL() const
Returns length of L area.
Definition: CoinAbcBaseFactorization.hpp:233
CoinAbcTypeFactorization::clearArrays
void clearArrays()
Get rid of all memory.
Definition: CoinAbcBaseFactorization.hpp:506
CoinAbcTypeFactorization::setYesGotUCopy
void setYesGotUCopy()
Definition: CoinAbcBaseFactorization.hpp:1150
scatterUpdate
void(* scatterUpdate)(int, CoinFactorizationDouble, const CoinFactorizationDouble *, double *) SCATTER_ATTRIBUTE
Definition: CoinAbcHelperFunctions.hpp:533
CoinAbcTypeFactorization::updateColumn
virtual CoinSimplexInt updateColumn(CoinIndexedVector &regionSparse) const
This version has same effect as above with FTUpdate==false so number returned is always &gt;=0...
CoinAbcTypeFactorization::numberInColumn
virtual CoinSimplexInt * numberInColumn() const
Number of entries in each column.
Definition: CoinAbcBaseFactorization.hpp:256
CoinSimplexDouble
double CoinSimplexDouble
Definition: CoinAbcCommon.hpp:21
CoinAbcTypeFactorization::unpack
void unpack(CoinIndexedVector *regionFrom, CoinIndexedVector *regionTo) const
CoinAbcTypeFactorization::lastEntryByColumnU_
CoinBigIndex lastEntryByColumnU_
Last entry by column for U.
Definition: CoinAbcBaseFactorization.hpp:943
CoinAbcTypeFactorization::updateColumnTransposeLByRow
void updateColumnTransposeLByRow(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by row.
CoinAbcTypeFactorization::lastEntryByRowU_
CoinBigIndex lastEntryByRowU_
Last entry by row for U.
Definition: CoinAbcBaseFactorization.hpp:951
CoinAbcTypeFactorization::updateColumnUDense
void updateColumnUDense(CoinIndexedVector *regionSparse) const
Updates part of column (FTRANU) when dense (i.e. do as inner products)
CoinAbcTypeFactorization::updateColumnTranspose
virtual CoinSimplexInt updateColumnTranspose(CoinIndexedVector &regionSparse) const
Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - i...
CoinAbcTypeFactorization::ftranFTAverageAfterR_
double ftranFTAverageAfterR_
Definition: CoinAbcBaseFactorization.hpp:1070
CoinAbcTypeFactorization::setNoGotRCopy
void setNoGotRCopy()
Definition: CoinAbcBaseFactorization.hpp:1146
CoinAbcTypeFactorization::replaceColumnU
int replaceColumnU(CoinIndexedVector *regionSparse, CoinBigIndex *deletedPosition, CoinSimplexInt *deletedColumns, CoinSimplexInt pivotRow)
Combines BtranU and store which elements are to be deleted returns number to be deleted.
CoinAbcTypeFactorization::maximumRows_
CoinSimplexInt maximumRows_
Maximum rows (ever) (here to use double alignment)
Definition: CoinAbcBaseFactorization.hpp:1063
CoinAbcTypeFactorization::ftranFTAverageAfterU_
double ftranFTAverageAfterU_
Definition: CoinAbcBaseFactorization.hpp:1071
CoinAbcTypeFactorization::permuteAddress_
CoinSimplexInt * permuteAddress_
Definition: CoinAbcBaseFactorization.hpp:838
ABC_FAC_GOT_UCOPY
#define ABC_FAC_GOT_UCOPY
Definition: CoinAbcCommonFactorization.hpp:69
CoinAbcTypeFactorization::convertRowToColumnUAddress_
CoinBigIndex * convertRowToColumnUAddress_
Definition: CoinAbcBaseFactorization.hpp:851
CoinFactorizationDoubleArrayWithLength::array
CoinFactorizationDouble * array() const
Get Array.
Definition: CoinIndexedVector.hpp:682
CoinAbcTypeFactorization::nextColumn_
CoinIntArrayWithLength nextColumn_
Next Column in memory order.
Definition: CoinAbcBaseFactorization.hpp:980
CoinAbcTypeFactorization::setNoGotUCopy
void setNoGotUCopy()
Definition: CoinAbcBaseFactorization.hpp:1149
CoinAbcTypeFactorization::ftranFTCountInput_
double ftranFTCountInput_
Definition: CoinAbcBaseFactorization.hpp:1065
CoinAbcTypeFactorization::nextCount
CoinSimplexInt * nextCount() const
Next Row/Column with count.
Definition: CoinAbcBaseFactorization.hpp:147
ABC_SMALL
#define ABC_SMALL
Definition: CoinAbcFactorization.hpp:35
CoinFactorizationDouble
double CoinFactorizationDouble
Definition: CoinTypes.hpp:57
CoinAbcTypeFactorization::updateColumnTransposeUDensish
void updateColumnTransposeUDensish(CoinIndexedVector *region, CoinSimplexInt smallestIndex) const
Updates part of column transpose (BTRANU) when densish, assumes index is sorted i.e.
CoinAbcTypeFactorization::numberL
CoinBigIndex numberL() const
Number in L.
Definition: CoinAbcBaseFactorization.hpp:159
CoinAbcTypeFactorization::fromLongArray
void fromLongArray(int which) const
From a work array and dis-associate vector.
Definition: CoinAbcBaseFactorization.hpp:308
CoinAbcTypeFactorization::indexRowL
CoinSimplexInt * indexRowL() const
Row indices of L.
Definition: CoinAbcBaseFactorization.hpp:99
CoinAbcTypeFactorization::workArea2Address_
CoinSimplexUnsignedInt * workArea2Address_
Definition: CoinAbcBaseFactorization.hpp:895
CoinAbcTypeFactorization::ftranCountInput_
double ftranCountInput_
To decide how to solve.
Definition: CoinAbcBaseFactorization.hpp:1049
CoinAbcTypeFactorization::updateColumnFTPart1
virtual int updateColumnFTPart1(CoinIndexedVector &regionSparse)
CoinAbcTypeFactorization::pivotColumn_
CoinIntArrayWithLength pivotColumn_
Pivot order for each Column.
Definition: CoinAbcBaseFactorization.hpp:965
CoinAbcTypeFactorization::pivotColumn
virtual CoinSimplexInt * pivotColumn() const
Returns address of pivotColumn region (also used for permuting)
Definition: CoinAbcBaseFactorization.hpp:75
AbcCommon.hpp
CoinAbcTypeFactorization::elementByRowLAddress_
CoinFactorizationDouble * elementByRowLAddress_
Definition: CoinAbcBaseFactorization.hpp:890
CoinAbcTypeFactorization::updateColumnFT
virtual CoinSimplexInt updateColumnFT(CoinIndexedVector &regionSparse)
Later take out return codes (apart from +- 1 on FT)
CoinAbcTypeFactorization::baseL_
CoinBigIndex baseL_
Base of L.
Definition: CoinAbcBaseFactorization.hpp:929
CoinAbcTypeFactorization::convertColumnToRowU_
CoinBigIndexArrayWithLength convertColumnToRowU_
Converts columns to rows in U.
Definition: CoinAbcBaseFactorization.hpp:1010
CoinBigIndexArrayWithLength
CoinBigIndex * version.
Definition: CoinIndexedVector.hpp:835
CoinAbcTypeFactorization::numberInColumn_
CoinIntArrayWithLength numberInColumn_
Number in each Column.
Definition: CoinAbcBaseFactorization.hpp:973
CoinIndexedVector
Indexed Vector.
Definition: CoinIndexedVector.hpp:104
CoinAbcTypeFactorization::pivotColumnAddress_
CoinSimplexInt * pivotColumnAddress_
Definition: CoinAbcBaseFactorization.hpp:837
CoinAbcTypeFactorization::gutsOfCopy
void gutsOfCopy(const CoinAbcTypeFactorization &other)
CoinAbcTypeFactorization::elements
virtual CoinFactorizationDouble * elements() const
Returns array to put basis elements in.
Definition: CoinAbcBaseFactorization.hpp:259
CoinIndexedVector::scan
int scan()
Scan dense region and set up indices (returns number found)
CoinAbcTypeFactorization::ftranCountAfterL_
double ftranCountAfterL_
Definition: CoinAbcBaseFactorization.hpp:1050
CoinAbcTypeFactorization::updateColumnTransposeLSparse
void updateColumnTransposeLSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparse (by Row)
CoinAbcTypeFactorization::workArea_
CoinFactorizationDoubleArrayWithLength workArea_
First work area.
Definition: CoinAbcBaseFactorization.hpp:1028
CoinAbcTypeFactorization::btranFullAverageAfterL_
double btranFullAverageAfterL_
Definition: CoinAbcBaseFactorization.hpp:1121
CoinAbcTypeFactorization::btranCountAfterU_
double btranCountAfterU_
Definition: CoinAbcBaseFactorization.hpp:1084
CoinAbcTypeFactorization::gotUCopy
bool gotUCopy() const
Definition: CoinAbcBaseFactorization.hpp:1148
CoinAbcTypeFactorization::maximumU_
CoinBigIndex maximumU_
Maximum space used in U.
Definition: CoinAbcBaseFactorization.hpp:937
CoinAbcTypeFactorization::indexRowU_
CoinIntArrayWithLength indexRowU_
Row indices of U.
Definition: CoinAbcBaseFactorization.hpp:998
CoinAbcTypeFactorization::nextCountAddress_
CoinSimplexInt * nextCountAddress_
Next Row/Column with count.
Definition: CoinAbcBaseFactorization.hpp:864
CoinAbcTypeFactorization::pivotLOrderAddress_
CoinSimplexInt * pivotLOrderAddress_
Definition: CoinAbcBaseFactorization.hpp:883
CoinAbcTypeFactorization::lengthU_
CoinBigIndex lengthU_
Length of U.
Definition: CoinAbcBaseFactorization.hpp:939
CoinAbcTypeFactorization::saveColumnAddress_
CoinSimplexInt * saveColumnAddress_
Definition: CoinAbcBaseFactorization.hpp:871
CoinAbcTypeFactorization::indexRowRAddress_
CoinSimplexInt * indexRowRAddress_
Row indices for R.
Definition: CoinAbcBaseFactorization.hpp:888
CoinAbcTypeFactorization::updateColumnL
void updateColumnL(CoinIndexedVector *region, CoinAbcStatistics &statistics) const
Updates part of column (FTRANL)
CoinAbcTypeFactorization::updateColumnTransposeRSparse
void updateColumnTransposeRSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when sparse.
CoinAbcTypeFactorization::startRowU_
CoinBigIndexArrayWithLength startRowU_
Start of each Row as pointer.
Definition: CoinAbcBaseFactorization.hpp:969
CoinAbcTypeFactorization::initialNumberRows_
CoinSimplexInt initialNumberRows_
Rows first time nonzero.
Definition: CoinAbcBaseFactorization.hpp:1114
CoinAbcTypeFactorization::indexRowLAddress_
CoinSimplexInt * indexRowLAddress_
Definition: CoinAbcBaseFactorization.hpp:876
CoinAbcTypeFactorization::nextRowAddress_
CoinSimplexInt * nextRowAddress_
Definition: CoinAbcBaseFactorization.hpp:869
CoinAbcTypeFactorization::updateFullColumnTranspose
virtual void updateFullColumnTranspose(CoinIndexedVector &regionSparse) const
Updates one full column (BTRAN)
CoinAbcTypeFactorization::updateColumnLDense
void updateColumnLDense(CoinIndexedVector *region) const
Updates part of column (FTRANL) when dense (i.e. do as inner products)
CoinAbcTypeFactorization::elementRAddress_
CoinFactorizationDouble * elementRAddress_
Elements of R.
Definition: CoinAbcBaseFactorization.hpp:886
CoinAbcTypeFactorization::updateColumnR
void updateColumnR(CoinIndexedVector *region, CoinAbcStatistics &statistics) const
Updates part of column (FTRANR) without FT update.
CoinAbcTypeFactorization::elementRowUAddress_
CoinFactorizationDouble * elementRowUAddress_
Definition: CoinAbcBaseFactorization.hpp:857
CoinAbcTypeFactorization::adjustedAreaFactor
CoinSimplexDouble adjustedAreaFactor() const
Returns areaFactor but adjusted for dense.
CoinAbcTypeFactorization::permute
CoinSimplexInt * permute() const
Returns address of permute region.
Definition: CoinAbcBaseFactorization.hpp:68
CoinAbcTypeFactorization::indexColumnUAddress_
CoinSimplexInt * indexColumnUAddress_
Definition: CoinAbcBaseFactorization.hpp:861
CoinAbcTypeFactorization::totalElements_
CoinBigIndex totalElements_
Number of elements in U (to go) or while iterating total overall.
Definition: CoinAbcBaseFactorization.hpp:913
CoinAbcTypeFactorization::nextRow_
CoinIntArrayWithLength nextRow_
Next Row in memory order.
Definition: CoinAbcBaseFactorization.hpp:984
CoinAbcTypeFactorization::checkPivot
CoinSimplexInt checkPivot(CoinSimplexDouble saveFromU, CoinSimplexDouble oldPivot) const
Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular. ...
CoinCheckZero
unsigned char CoinCheckZero
Definition: CoinAbcCommon.hpp:230
CoinAbcTypeFactorization::workAreaAddress_
CoinFactorizationDouble * workAreaAddress_
Definition: CoinAbcBaseFactorization.hpp:894
CoinAbcTypeFactorization::workArea2_
CoinUnsignedIntArrayWithLength workArea2_
Second work area.
Definition: CoinAbcBaseFactorization.hpp:1030
CoinAbcTypeFactorization
Definition: CoinAbcBaseFactorization.hpp:28
CoinAbcTypeFactorization::setNoGotLCopy
void setNoGotLCopy()
Definition: CoinAbcBaseFactorization.hpp:1143
CoinAbcTypeFactorization::startColumnL_
CoinBigIndexArrayWithLength startColumnL_
Start of each column in L.
Definition: CoinAbcBaseFactorization.hpp:1022
CoinAbcTypeFactorization::pivot
int pivot(CoinSimplexInt pivotRow, CoinSimplexInt pivotColumn, CoinBigIndex pivotRowPosition, CoinBigIndex pivotColumnPosition, CoinFactorizationDouble *COIN_RESTRICT work, CoinSimplexUnsignedInt *COIN_RESTRICT workArea2, CoinSimplexInt increment2, int *COIN_RESTRICT markRow)
0 fine, -99 singular, 2 dense
CoinAbcTypeFactorization::toLongArray
void toLongArray(CoinIndexedVector *vector, int which) const
To a work array and associate vector.
Definition: CoinAbcBaseFactorization.hpp:304
CoinAbcTypeFactorization::resetStatistics
void resetStatistics()
Reset all sparsity etc statistics.
CoinAbcTypeFactorization::updateColumnLSparse
void updateColumnLSparse(CoinIndexedVector *region) const
Updates part of column (FTRANL) when sparse.
CoinAbcTypeFactorization::pivotRegion
virtual CoinFactorizationDouble * pivotRegion() const
Returns address of pivot region.
Definition: CoinAbcBaseFactorization.hpp:79
CoinAbcTypeFactorization::numberRowsLeft_
CoinSimplexInt numberRowsLeft_
Number Rows left (numberRows-numberGood)
Definition: CoinAbcBaseFactorization.hpp:910
CoinAbcTypeFactorization::operator=
CoinAbcTypeFactorization & operator=(const CoinAbcTypeFactorization &other)
= copy
CoinAbcTypeFactorization::conditionNumber
CoinSimplexDouble conditionNumber() const
Condition number - product of pivots after factorization.
CoinAbcTypeFactorization::pivotLinkedForwardsAddress_
CoinSimplexInt * pivotLinkedForwardsAddress_
Definition: CoinAbcBaseFactorization.hpp:882
CoinAbcTypeFactorization::sparse_
CoinIntArrayWithLength sparse_
Sparse regions.
Definition: CoinAbcBaseFactorization.hpp:1039
CoinAbcTypeFactorization::~CoinAbcTypeFactorization
virtual ~CoinAbcTypeFactorization()
Destructor.
CoinAbcTypeFactorization::state_
CoinSimplexInt state_
State of saved version and what can be done 0 - nothing saved 1 - saved and can go back to previous s...
Definition: CoinAbcBaseFactorization.hpp:1136
CoinAbcTypeFactorization::lastColumnAddress_
CoinSimplexInt * lastColumnAddress_
Definition: CoinAbcBaseFactorization.hpp:868
CoinAbcAnyFactorization::checkReplacePart1a
virtual void checkReplacePart1a(CoinIndexedVector *, int)
Definition: CoinAbcDenseFactorization.hpp:256
CoinAbcTypeFactorization::updateColumnU
void updateColumnU(CoinIndexedVector *region, CoinAbcStatistics &statistics) const
Updates part of column (FTRANU)
CoinAbcTypeFactorization::postProcess
virtual void postProcess(const CoinSimplexInt *sequence, CoinSimplexInt *pivotVariable)
Does post processing on valid factorization - putting variables on correct rows.
CoinAbcTypeFactorization::elementLAddress_
CoinFactorizationDouble * elementLAddress_
Definition: CoinAbcBaseFactorization.hpp:875
CoinAbcTypeFactorization::numberElementsU
CoinBigIndex numberElementsU() const
Returns number in U area.
Definition: CoinAbcBaseFactorization.hpp:218
CoinAbcTypeFactorization::numberInColumnPlusAddress_
CoinSimplexInt * numberInColumnPlusAddress_
Definition: CoinAbcBaseFactorization.hpp:843
CoinAbcTypeFactorization::sort
void sort() const
Debug - sort so can compare.
CoinAbcTypeFactorization::ftranFullCountAfterR_
double ftranFullCountAfterR_
Definition: CoinAbcBaseFactorization.hpp:1102
CoinAbcTypeFactorization::denseAreaAddress_
CoinFactorizationDouble * denseAreaAddress_
Definition: CoinAbcBaseFactorization.hpp:892
CoinAbcTypeFactorization::pivotLOrder
CoinSimplexInt * pivotLOrder() const
Definition: CoinAbcBaseFactorization.hpp:114
CoinAbcTypeFactorization::btranAverageAfterU_
double btranAverageAfterU_
Definition: CoinAbcBaseFactorization.hpp:1087
CoinAbcTypeFactorization::pack
void pack(CoinIndexedVector *regionFrom, CoinIndexedVector *regionTo) const
CoinAbcTypeFactorization::lastRowAddress_
CoinSimplexInt * lastRowAddress_
Definition: CoinAbcBaseFactorization.hpp:870
CoinAbcTypeFactorization::printRegion
void printRegion(const CoinIndexedVector &vector, const char *where) const
CoinAbcTypeFactorization::updateColumnCpu
virtual void updateColumnCpu(CoinIndexedVector &regionSparse, int whichCpu) const
Updates one column (FTRAN)
CoinFactorizationDoubleArrayWithLength
CoinFactorizationDouble * version.
Definition: CoinIndexedVector.hpp:673
CoinAbcTypeFactorization::storeFT
bool storeFT(const CoinIndexedVector *regionFT)
Store update after doing L and R - retuns false if no room.
CoinAbcTypeFactorization::elementByRowL
CoinFactorizationDouble * elementByRowL() const
Elements in L (row copy)
Definition: CoinAbcBaseFactorization.hpp:104
CoinAbcStatistics
Definition: CoinAbcCommonFactorization.hpp:32
CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:105
CoinAbcTypeFactorization::numberRowsExtra
CoinSimplexInt numberRowsExtra() const
Number of Rows after iterating.
Definition: CoinAbcBaseFactorization.hpp:155
CoinAbcTypeFactorization::scan
void scan(CoinIndexedVector *vector) const
Scans region to find nonzeros.
Definition: CoinAbcBaseFactorization.hpp:310
CoinAbcTypeFactorization::updateColumnTransposeUByColumn
void updateColumnTransposeUByColumn(CoinIndexedVector *region, CoinSimplexInt smallestIndex) const
Updates part of column transpose (BTRANU) by column assumes index is sorted i.e.
CoinAbcTypeFactorization::checkReplacePart1
virtual double checkReplacePart1(CoinIndexedVector *regionSparse, int pivotRow)
Checks if can replace one Column to basis, returns update alpha Fills in region for use later partial...
CoinAbcTypeFactorization::elementU_
CoinFactorizationDoubleArrayWithLength elementU_
Elements of U.
Definition: CoinAbcBaseFactorization.hpp:996
CoinAbcTypeFactorization::numberElements
virtual CoinBigIndex numberElements() const
Total number of elements in factorization.
Definition: CoinAbcBaseFactorization.hpp:170
CoinAbcTypeFactorization::denseArea_
CoinFactorizationDoubleArrayWithLength denseArea_
Dense area.
Definition: CoinAbcBaseFactorization.hpp:1025
ABC_FAC_GOT_RCOPY
#define ABC_FAC_GOT_RCOPY
Definition: CoinAbcCommonFactorization.hpp:68
CoinAbcTypeFactorization::ftranFullAverageAfterR_
double ftranFullAverageAfterR_
Definition: CoinAbcBaseFactorization.hpp:1105
CoinAbcTypeFactorization::pivotOneOtherRow
bool pivotOneOtherRow(CoinSimplexInt pivotRow, CoinSimplexInt pivotColumn)
Pivots when just one other row so faster?
CoinAbcTypeFactorization::numberFtranFTCounts_
CoinSimplexInt numberFtranFTCounts_
Definition: CoinAbcBaseFactorization.hpp:1076
CoinAbcTypeFactorization::cleanup
void cleanup()
Cleans up at end of factorization.
CoinFactorizationLongDoubleArrayWithLength
CoinFactorizationLongDouble * version.
Definition: CoinIndexedVector.hpp:727
scatterStruct
Definition: CoinAbcHelperFunctions.hpp:534
CoinAbcTypeFactorization::updateColumnTransposePFI
void updateColumnTransposePFI(CoinIndexedVector *region) const
Updates part of column transpose PFI (BTRAN) (before rest)
FACTOR_CPU
#define FACTOR_CPU
This deals with Factorization and Updates.
Definition: CoinAbcBaseFactorization.hpp:23
CoinAbcTypeFactorization::replaceColumnPart3
virtual void replaceColumnPart3(const AbcSimplex *model, CoinIndexedVector *regionSparse, CoinIndexedVector *tableauColumn, int pivotRow, double alpha)
Replaces one Column to basis, partial update already in U.
CoinFactorization
This deals with Factorization and Updates.
Definition: CoinFactorization.hpp:50
CoinAbcTypeFactorization::messageLevel_
CoinSimplexInt messageLevel_
Detail in messages.
Definition: CoinAbcBaseFactorization.hpp:1042
CoinAbcTypeFactorization::lengthAreaU
CoinBigIndex lengthAreaU() const
Returns length of U area.
Definition: CoinAbcBaseFactorization.hpp:225
CoinAbcTypeFactorization::startColumnRAddress_
CoinBigIndex * startColumnRAddress_
Definition: CoinAbcBaseFactorization.hpp:884
CoinAbcTypeFactorization::updateFullColumn
virtual void updateFullColumn(CoinIndexedVector &regionSparse) const
Updates one full column (FTRAN)
CoinAbcTypeFactorization::setNoGotSparse
void setNoGotSparse()
Definition: CoinAbcBaseFactorization.hpp:1152
CoinAbcTypeFactorization::lengthAreaL_
CoinBigIndex lengthAreaL_
Length of area reserved for L.
Definition: CoinAbcBaseFactorization.hpp:933
CoinAbcAnyFactorization::checkReplacePart1b
virtual double checkReplacePart1b(CoinIndexedVector *, int)
Definition: CoinAbcDenseFactorization.hpp:259
CoinIntArrayWithLength::array
int * array() const
Get Array.
Definition: CoinIndexedVector.hpp:790
CoinAbcTypeFactorization::modifyLink
void modifyLink(CoinSimplexInt index, CoinSimplexInt count)
Modifies links in chain of equal counts.
Definition: CoinAbcBaseFactorization.hpp:641
CoinAbcTypeFactorization::wantsTableauColumn
virtual bool wantsTableauColumn() const
Returns true if wants tableauColumn in replaceColumn.
Definition: CoinAbcBaseFactorization.hpp:427
CoinAbcTypeFactorization::startColumnUAddress_
CoinBigIndex * startColumnUAddress_
Definition: CoinAbcBaseFactorization.hpp:849
CoinAbcTypeFactorization::saveColumn_
CoinIntArrayWithLength saveColumn_
Columns left to do in a single pivot.
Definition: CoinAbcBaseFactorization.hpp:988
CoinAbcTypeFactorization::updateColumnTransposeU
void updateColumnTransposeU(CoinIndexedVector *region, CoinSimplexInt smallestIndex, CoinAbcStatistics &statistics) const
Updates part of column transpose (BTRANU), assumes index is sorted i.e.
CoinAbcTypeFactorization::updateColumnLDensish
void updateColumnLDensish(CoinIndexedVector *region) const
Updates part of column (FTRANL) when densish.
CoinAbcTypeFactorization::btranFullCountInput_
double btranFullCountInput_
To decide how to solve.
Definition: CoinAbcBaseFactorization.hpp:1117
CoinAbcTypeFactorization::updateTwoColumnsFT
virtual CoinSimplexInt updateTwoColumnsFT(CoinIndexedVector &regionFT, CoinIndexedVector &regionOther)
Updates one column (FTRAN) from region2 Tries to do FT update number returned is negative if no room...
CoinAbcTypeFactorization::sparseThreshold_
CoinSimplexInt sparseThreshold_
Below this use sparse technology - if 0 then no L row copy.
Definition: CoinAbcBaseFactorization.hpp:918
CoinAbcTypeFactorization::numberR_
CoinSimplexInt numberR_
Number in R.
Definition: CoinAbcBaseFactorization.hpp:921
CoinAbcTypeFactorization::gutsOfDestructor
void gutsOfDestructor(CoinSimplexInt type=1)
The real work of constructors etc 0 just scalars, 1 bit normal.
CoinAbcTypeFactorization::indexRowUAddress_
CoinSimplexInt * indexRowUAddress_
Definition: CoinAbcBaseFactorization.hpp:841
CoinIntArrayWithLength
int * version
Definition: CoinIndexedVector.hpp:781
CoinAbcTypeFactorization::elementByRowL_
CoinFactorizationDoubleArrayWithLength elementByRowL_
Elements in L (row copy)
Definition: CoinAbcBaseFactorization.hpp:1037
CoinAbcTypeFactorization::updateColumnUSparse
void updateColumnUSparse(CoinIndexedVector *regionSparse) const
Updates part of column (FTRANU) when sparse.
CoinSimplexInt
int CoinSimplexInt
Definition: CoinAbcCommon.hpp:22
CoinAbcTypeFactorization::getColumnSpaceIterate
CoinBigIndex getColumnSpaceIterate(CoinSimplexInt iColumn, CoinFactorizationDouble value, CoinSimplexInt iRow)
getColumnSpaceIterate.
CoinAbcTypeFactorization::getColumnSpaceIterateR
bool getColumnSpaceIterateR(CoinSimplexInt iColumn, CoinFactorizationDouble value, CoinSimplexInt iRow)
getColumnSpaceIterateR.
CoinAbcTypeFactorization::wantToGoDense
int wantToGoDense()
After pivoting - returns true if need to go dense.
CoinAbcTypeFactorization::markRowAddress_
CoinCheckZero * markRowAddress_
Definition: CoinAbcBaseFactorization.hpp:873
CoinAbcTypeFactorization::lengthAreaU_
CoinBigIndex lengthAreaU_
Length of area reserved for U.
Definition: CoinAbcBaseFactorization.hpp:941
CoinAbcTypeFactorization::firstCount
CoinSimplexInt * firstCount() const
For equal counts in factorization.
Definition: CoinAbcBaseFactorization.hpp:143
CoinAbcTypeFactorization::permute_
CoinIntArrayWithLength permute_
Permutation vector for pivot row order.
Definition: CoinAbcBaseFactorization.hpp:967
CoinAbcTypeFactorization::btranFullAverageAfterU_
double btranFullAverageAfterU_
Definition: CoinAbcBaseFactorization.hpp:1123
CoinAbcTypeFactorization::gotLCopy
bool gotLCopy() const
Definition: CoinAbcBaseFactorization.hpp:1142
ABC_FAC_GOT_LCOPY
#define ABC_FAC_GOT_LCOPY
Definition: CoinAbcCommonFactorization.hpp:67
CoinAbcTypeFactorization::makeNonSingular
virtual void makeNonSingular(CoinSimplexInt *sequence)
Makes a non-singular basis by replacing variables.
CoinAbcTypeFactorization::factorSparse
CoinSimplexInt factorSparse()
Does sparse phase of factorization return code is &lt;0 error, 0= finished.
CoinAbcTypeFactorization::show_self
void show_self() const
Debug show object (shows one representation)
CoinAbcTypeFactorization::getColumnSpace
bool getColumnSpace(CoinSimplexInt iColumn, CoinSimplexInt extraNeeded)
Gets space for one Column with given length, may have to do compression (returns True if successful)...
CoinArbitraryArrayWithLength
arbitrary version
Definition: CoinIndexedVector.hpp:997
CoinAbcTypeFactorization::goSparse
void goSparse()
makes a row copy of L for speed and to allow very sparse problems
Definition: CoinAbcBaseFactorization.hpp:487
CoinAbcTypeFactorization::gotRCopy
bool gotRCopy() const
Definition: CoinAbcBaseFactorization.hpp:1145
CoinAbcTypeFactorization::denseVector
double * denseVector(CoinIndexedVector *vector) const
Returns double * associated with vector.
Definition: CoinAbcBaseFactorization.hpp:294
CoinAbcTypeFactorization::maximumRowsExtra
CoinSimplexInt maximumRowsExtra() const
Maximum of Rows after iterating.
Definition: CoinAbcBaseFactorization.hpp:166
CoinAbcTypeFactorization::denseThreshold
CoinSimplexInt denseThreshold() const
Gets dense threshold.
Definition: CoinAbcBaseFactorization.hpp:189
CoinAbcTypeFactorization::numberInRowAddress_
CoinSimplexInt * numberInRowAddress_
Definition: CoinAbcBaseFactorization.hpp:860
CoinAbcTypeFactorization::numberElementsR
CoinBigIndex numberElementsR() const
Returns number in R area.
Definition: CoinAbcBaseFactorization.hpp:237
CoinAbcTypeFactorization::btranFullAverageAfterR_
double btranFullAverageAfterR_
Definition: CoinAbcBaseFactorization.hpp:1122
CoinAbcTypeFactorization::numberCompressions
CoinBigIndex numberCompressions() const
Number of compressions done.
Definition: CoinAbcBaseFactorization.hpp:241
CoinAbcTypeFactorization::maximumCoefficient
CoinSimplexDouble maximumCoefficient() const
Returns maximum absolute value in factorization.
CoinAbcTypeFactorization::sparseThreshold
CoinSimplexInt sparseThreshold() const
get sparse threshold
Definition: CoinAbcBaseFactorization.hpp:494
CoinAbcTypeFactorization::indexRowU
CoinSimplexInt * indexRowU() const
Row indices of U.
Definition: CoinAbcBaseFactorization.hpp:268
CoinAbcTypeFactorization::ftranFullCountInput_
double ftranFullCountInput_
To decide how to solve.
Definition: CoinAbcBaseFactorization.hpp:1100
CoinAbcTypeFactorization::indices
virtual CoinSimplexInt * indices() const
Returns array to put basis indices in.
Definition: CoinAbcBaseFactorization.hpp:72
CoinAbcTypeFactorization::pivotLinkedBackwardsAddress_
CoinSimplexInt * pivotLinkedBackwardsAddress_
Definition: CoinAbcBaseFactorization.hpp:881
CoinAbcTypeFactorization::numberBtranFullCounts_
CoinSimplexInt numberBtranFullCounts_
Definition: CoinAbcBaseFactorization.hpp:1128
CoinAbcAnyFactorization::maximumPivots
int maximumPivots() const
Maximum number of pivots between factorizations.
Definition: CoinAbcDenseFactorization.hpp:93
CoinAbcAnyFactorization::zeroTolerance_
double zeroTolerance_
Zero tolerance.
Definition: CoinAbcDenseFactorization.hpp:342
CoinAbcTypeFactorization::indexColumnL_
CoinIntArrayWithLength indexColumnL_
Index of column in row for L.
Definition: CoinAbcBaseFactorization.hpp:1035
CoinAbcTypeFactorization::starts
virtual CoinBigIndex * starts() const
Returns pivot row.
Definition: CoinAbcBaseFactorization.hpp:250
CoinAbcTypeFactorization::ftranCountAfterR_
double ftranCountAfterR_
Definition: CoinAbcBaseFactorization.hpp:1051
CoinAbcTypeFactorization::almostDestructor
void almostDestructor()
Delete all stuff (leaves as after CoinAbcFactorization())
CoinAbcTypeFactorization::convertRowToColumnU_
CoinBigIndexArrayWithLength convertRowToColumnU_
Converts rows to columns in U.
Definition: CoinAbcBaseFactorization.hpp:1007
CoinAbcTypeFactorization::updateColumnPFI
void updateColumnPFI(CoinIndexedVector *regionSparse) const
Updates part of column PFI (FTRAN) (after rest)
CoinAbcTypeFactorization::btranCountInput_
double btranCountInput_
Definition: CoinAbcBaseFactorization.hpp:1083
CoinAbcTypeFactorization::numberCompressions_
CoinBigIndex numberCompressions_
Number of compressions done.
Definition: CoinAbcBaseFactorization.hpp:1044
CoinAbcTypeFactorization::getRowSpace
bool getRowSpace(CoinSimplexInt iRow, CoinSimplexInt extraNeeded)
Gets space for one Row with given length, may have to do compression (returns True if successful)...
CoinSimplexUnsignedInt
unsigned int CoinSimplexUnsignedInt
Definition: CoinAbcCommon.hpp:23
CoinAbcTypeFactorization::listAddress_
CoinSimplexInt * listAddress_
Definition: CoinAbcBaseFactorization.hpp:874
CoinAbcTypeFactorization::denseVector
const double * denseVector(const CoinIndexedVector *vector) const
Returns double * associated with vector.
Definition: CoinAbcBaseFactorization.hpp:299