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
CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:105
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::numberGoodU_
int numberGoodU_
Number factorized in U (not row singletons)
Definition: CoinFactorization.hpp:1324
CoinFactorization::slackValue
double slackValue() const
Whether slack value is +1 or -1.
Definition: CoinFactorization.hpp:277
CoinFactorization::startColumnL
CoinBigIndex * startColumnL() const
Start of each column in L.
Definition: CoinFactorization.hpp:181
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::addColumn
int addColumn(CoinBigIndex numberElements, int indicesRow[], double elements[])
Adds one Column to basis, can increase size of basis.
CoinFactorization::factorDense
int factorDense()
Does dense phase of factorization return code is &lt;0 error, 0= finished.
CoinFactorization::ftranCountAfterL_
double ftranCountAfterL_
Pivot tolerance.
Definition: CoinFactorization.hpp:1509
CoinFactorization::totalElements_
CoinBigIndex totalElements_
Number of elements in U (to go) or while iterating total overall.
Definition: CoinFactorization.hpp:1333
CoinFactorization::lengthAreaU
CoinBigIndex lengthAreaU() const
Returns length of U area.
Definition: CoinFactorization.hpp:313
CoinFactorization::maximumColumnsExtra
int maximumColumnsExtra()
Maximum number of Columns after iterating.
Definition: CoinFactorization.hpp:347
CoinFactorization::numberElementsU
CoinBigIndex numberElementsU() const
Returns number in U area.
Definition: CoinFactorization.hpp:306
CoinFactorization::startRowL_
CoinBigIndexArrayWithLength startRowL_
Start of each row in L.
Definition: CoinFactorization.hpp:1544
CoinFactorization::updateColumnTransposeLSparse
void updateColumnTransposeLSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparse (by Row)
CoinFactorization::numberBtranCounts_
int numberBtranCounts_
Pivot tolerance.
Definition: CoinFactorization.hpp:1519
CoinFactorization::updateColumnTransposeUSparsish
void updateColumnTransposeUSparsish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when sparsish, assumes index is sorted i.e.
CoinFactorization::getColumnSpaceIterate
CoinBigIndex getColumnSpaceIterate(int iColumn, double value, int iRow)
getColumnSpaceIterate.
CoinFactorization::addRow
int addRow(CoinBigIndex numberElements, int indicesColumn[], double elements[])
Adds one Row to basis, can increase size of basis.
CoinFactorization::updateColumnTransposePFI
void updateColumnTransposePFI(CoinIndexedVector *region) const
Updates part of column transpose PFI (BTRAN) (before rest)
CoinFactorization::setBiasLU
void setBiasLU(int value)
Returns number of dense rows.
Definition: CoinFactorization.hpp:354
CoinFactorization::numberForrestTomlin
int numberForrestTomlin() const
Length of FT vector.
Definition: CoinFactorization.hpp:227
CoinFactorization::gutsOfCopy
void gutsOfCopy(const CoinFactorization &other)
See if worth going sparse.
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::indexColumnL
int * indexColumnL() const
Index of column in row for L.
Definition: CoinFactorization.hpp:185
CoinFactorization::zeroTolerance_
double zeroTolerance_
Zero tolerance.
Definition: CoinFactorization.hpp:1298
CoinFactorization::sparseThreshold_
int sparseThreshold_
Below this use sparse technology - if 0 then no L row copy.
Definition: CoinFactorization.hpp:1538
CoinFactorization::saveColumn_
CoinIntArrayWithLength saveColumn_
Columns left to do in a single pivot.
Definition: CoinFactorization.hpp:1390
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::clearArrays
void clearArrays()
Get rid of all memory.
Definition: CoinFactorization.hpp:532
CoinFactorization::workArea2_
CoinUnsignedIntArrayWithLength workArea2_
Second work area.
Definition: CoinFactorization.hpp:1501
CoinFactorization::updateColumnTransposeUDensish
void updateColumnTransposeUDensish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when densish, assumes index is sorted i.e.
CoinFactorization::pivotColumn
int * pivotColumn() const
Returns address of pivotColumn region (also used for permuting)
Definition: CoinFactorization.hpp:155
CoinFactorization::ftranCountAfterU_
double ftranCountAfterU_
Pivot tolerance.
Definition: CoinFactorization.hpp:1511
CoinFactorization::checkConsistency
void checkConsistency()
Checks that row and column copies look OK.
CoinFactorization::lengthR_
CoinBigIndex lengthR_
Length of R stuff.
Definition: CoinFactorization.hpp:1468
CoinFactorization::pivot
bool pivot(int pivotRow, int pivotColumn, CoinBigIndex pivotRowPosition, CoinBigIndex pivotColumnPosition, CoinFactorizationDouble work[], unsigned int workArea2[], int increment2, T markRow[], int largeInteger)
Gets space for a factorization, called by constructors.
Definition: CoinFactorization.hpp:812
CoinFactorization::numberTrials_
int numberTrials_
0 - no increasing rows - no permutations, 1 - no increasing rows but permutations 2 - increasing rows...
Definition: CoinFactorization.hpp:1354
CoinFactorization::baseL
CoinBigIndex baseL() const
Base of L.
Definition: CoinFactorization.hpp:212
CoinFactorization::deleteColumn
int deleteColumn(int Row)
Deletes one Column from basis, returns rank.
CoinFactorization::lengthAreaU_
CoinBigIndex lengthAreaU_
Length of area reserved for U.
Definition: CoinFactorization.hpp:1426
CoinFactorization::preProcess
void preProcess(int state, int possibleDuplicates=-1)
PreProcesses raw triplet data.
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::addLink
void addLink(int index, int count)
Adds a link in chain of equal counts.
Definition: CoinFactorization.hpp:669
CoinFactorization::numberL
CoinBigIndex numberL() const
Number in L.
Definition: CoinFactorization.hpp:208
CoinFactorization::indexColumnU_
CoinIntArrayWithLength indexColumnU_
Base address for U (may change)
Definition: CoinFactorization.hpp:1402
CoinFactorization::elementR_
CoinFactorizationDouble * elementR_
Elements of R.
Definition: CoinFactorization.hpp:1474
CoinFactorization::nextRow_
CoinIntArrayWithLength nextRow_
Next Row in memory order.
Definition: CoinFactorization.hpp:1384
CoinFactorization::pivotRowSingleton
bool pivotRowSingleton(int pivotRow, int pivotColumn)
Does one pivot on Row Singleton in factorization.
CoinFactorization::btranCountAfterR_
double btranCountAfterR_
Pivot tolerance.
Definition: CoinFactorization.hpp:1514
CoinFactorization::numberColumns
int numberColumns() const
Total number of columns in factorization.
Definition: CoinFactorization.hpp:219
CoinFactorization::gutsOfDestructor
void gutsOfDestructor(int type=1)
The real work of constructors etc 0 just scalars, 1 bit normal.
COINFACTORIZATION_BITS_PER_INT
#define COINFACTORIZATION_BITS_PER_INT
Definition: CoinFactorization.hpp:807
CoinFactorization::numberColumns_
int numberColumns_
Number of Columns in factorization.
Definition: CoinFactorization.hpp:1318
CoinFactorization::indexRowU
int * indexRowU() const
Row indices of U.
Definition: CoinFactorization.hpp:341
CoinFactorization::biggerDimension_
int biggerDimension_
Larger of row and column size.
Definition: CoinFactorization.hpp:1399
CoinFactorization::sparseThreshold2_
int sparseThreshold2_
And one for &quot;sparsish&quot;.
Definition: CoinFactorization.hpp:1541
CoinFactorization::lengthU_
CoinBigIndex lengthU_
Base of U is always 0.
Definition: CoinFactorization.hpp:1423
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::updateColumnTransposeRSparse
void updateColumnTransposeRSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when sparse.
CoinFactorization::numberL_
CoinBigIndex numberL_
Number in L.
Definition: CoinFactorization.hpp:1441
CoinFactorization::ftranCountAfterR_
double ftranCountAfterR_
Pivot tolerance.
Definition: CoinFactorization.hpp:1510
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::indexColumnL_
CoinIntArrayWithLength indexColumnL_
Index of column in row for L.
Definition: CoinFactorization.hpp:1547
CoinFactorization::sparseThreshold
int sparseThreshold() const
get sparse threshold
Definition: CoinFactorization.hpp:521
CoinFactorization::deleteRow
int deleteRow(int Row)
Deletes one Row from basis, returns rank.
CoinIntArrayWithLength::array
int * array() const
Get Array.
Definition: CoinIndexedVector.hpp:790
CoinFactorization::updateColumnUDensish
int updateColumnUDensish(double *COIN_RESTRICT region, int *COIN_RESTRICT regionIndex) const
Updates part of column (FTRANU)
CoinFactorization::indexRowL
int * indexRowL() const
Row indices of L.
Definition: CoinFactorization.hpp:189
CoinFactorization::ftranAverageAfterU_
double ftranAverageAfterU_
Pivot tolerance.
Definition: CoinFactorization.hpp:1524
CoinFactorization::setPersistenceFlag
void setPersistenceFlag(int value)
Returns number of dense rows.
CoinFactorization::elementU_
CoinFactorizationDoubleArrayWithLength elementU_
Elements of U.
Definition: CoinFactorization.hpp:1429
CoinFactorization::sparse_
CoinIntArrayWithLength sparse_
Sparse regions.
Definition: CoinFactorization.hpp:1553
CoinFactorization::numberElementsL
CoinBigIndex numberElementsL() const
Returns number in L area.
Definition: CoinFactorization.hpp:317
CoinFactorization::updateColumnTransposeUByColumn
void updateColumnTransposeUByColumn(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) by column assumes index is sorted i.e.
CoinFactorization::workArea_
CoinFactorizationDoubleArrayWithLength workArea_
First work area.
Definition: CoinFactorization.hpp:1498
CoinPackedMatrix
Sparse Matrix Base Class.
Definition: CoinPackedMatrix.hpp:79
CoinFactorization::maximumU_
CoinBigIndex maximumU_
Maximum space used in U.
Definition: CoinFactorization.hpp:1417
CoinFactorization::permute_
CoinIntArrayWithLength permute_
Permutation vector for pivot row order.
Definition: CoinFactorization.hpp:1339
CoinFactorization::numberCompressions_
CoinBigIndex numberCompressions_
Number of compressions done.
Definition: CoinFactorization.hpp:1504
CoinFactorization::ftranAverageAfterL_
double ftranAverageAfterL_
While these are average ratios collected over last period.
Definition: CoinFactorization.hpp:1522
CoinFactorization::forrestTomlin
bool forrestTomlin() const
true if Forrest Tomlin update, false if PFI
Definition: CoinFactorization.hpp:285
CoinFactorization::updateColumnUSparse
void updateColumnUSparse(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparse.
CoinFactorization::setNumberRows
void setNumberRows(int value)
Set number of Rows after factorization.
Definition: CoinFactorization.hpp:201
CoinFactorization::lastCount_
CoinIntArrayWithLength lastCount_
Previous Row/Column with count.
Definition: CoinFactorization.hpp:1375
CoinFactorization::numberElementsR
CoinBigIndex numberElementsR() const
Returns number in R area.
Definition: CoinFactorization.hpp:325
CoinFactorization::reorderU
bool reorderU()
Reorders U so contiguous and in order (if there is space) Returns true if it could.
CoinFactorization::CoinFactorization
CoinFactorization()
Default constructor.
CoinFactorization::collectStatistics
bool collectStatistics() const
For statistics.
Definition: CoinFactorization.hpp:579
CoinFactorization::updateColumnTransposeUSparse
void updateColumnTransposeUSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANU) when sparse, assumes index is sorted i.e.
CoinFactorization::adjustedAreaFactor
double adjustedAreaFactor() const
Returns areaFactor but adjusted for dense.
CoinFactorization::spaceForForrestTomlin
bool spaceForForrestTomlin() const
True if FT update and space.
Definition: CoinFactorization.hpp:290
CoinFactorization::numberInColumnPlus_
CoinIntArrayWithLength numberInColumnPlus_
Number in each Column including pivoted.
Definition: CoinFactorization.hpp:1365
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::areaFactor
void areaFactor(double value)
Returns status.
Definition: CoinFactorization.hpp:238
CoinFactorization::startRowU_
CoinBigIndexArrayWithLength startRowU_
Start of each Row as pointer.
Definition: CoinFactorization.hpp:1356
CoinFactorization::pivotOneOtherRow
bool pivotOneOtherRow(int pivotRow, int pivotColumn)
Pivots when just one other row so faster?
CoinFactorization::goSparse
void goSparse()
makes a row copy of L for speed and to allow very sparse problems
CoinFactorization::numberColumnsExtra_
int numberColumnsExtra_
Number of Columns after iterating.
Definition: CoinFactorization.hpp:1320
CoinFactorization::ftranCountInput_
double ftranCountInput_
Below are all to collect.
Definition: CoinFactorization.hpp:1508
CoinFactorization::factorElements_
CoinBigIndex factorElements_
Number of elements after factorization.
Definition: CoinFactorization.hpp:1335
CoinFactorization::lengthAreaL_
CoinBigIndex lengthAreaL_
Length of area reserved for L.
Definition: CoinFactorization.hpp:1450
CoinFactorization::updateColumnUSparsish
void updateColumnUSparsish(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparsish.
CoinFactorization::elementByRowL
CoinFactorizationDouble * elementByRowL() const
Elements in L (row copy)
Definition: CoinFactorization.hpp:193
CoinFactorization::updateColumnLDensish
void updateColumnLDensish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when densish.
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::denseAreaAddress_
double * denseAreaAddress_
Dense area - actually used (for alignment etc)
Definition: CoinFactorization.hpp:1486
CoinFactorization::maximumPivots_
int maximumPivots_
Maximum number of pivots before factorization.
Definition: CoinFactorization.hpp:1328
CoinFactorization::maximumColumnsExtra_
int maximumColumnsExtra_
Maximum number of Columns after iterating.
Definition: CoinFactorization.hpp:1322
CoinFactorization::pivotRegion_
CoinFactorizationDoubleArrayWithLength pivotRegion_
Inverses of pivot values.
Definition: CoinFactorization.hpp:1408
CoinFactorization::pivotColumn_
CoinIntArrayWithLength pivotColumn_
Pivot order for each Column.
Definition: CoinFactorization.hpp:1337
CoinFactorization::updateColumnTransposeU
void updateColumnTransposeU(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU), assumes index is sorted i.e.
CoinFactorization::startColumnR_
CoinBigIndexArrayWithLength startColumnR_
Start of columns for R.
Definition: CoinFactorization.hpp:1480
CoinFactorization::elementU
CoinFactorizationDouble * elementU() const
Elements of U.
Definition: CoinFactorization.hpp:338
CoinFactorization::updateColumnTransposeLDensish
void updateColumnTransposeLDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by column.
CoinFactorization::indexRowL_
CoinIntArrayWithLength indexRowL_
Row indices of L.
Definition: CoinFactorization.hpp:1456
CoinFactorization::btranAverageAfterR_
double btranAverageAfterR_
Pivot tolerance.
Definition: CoinFactorization.hpp:1526
CoinFactorization::denseArea_
double * denseArea_
Dense area.
Definition: CoinFactorization.hpp:1483
CoinFactorizationDouble
double CoinFactorizationDouble
Definition: CoinTypes.hpp:57
CoinFactorization::nextColumn_
CoinIntArrayWithLength nextColumn_
Next Column in memory order.
Definition: CoinFactorization.hpp:1378
CoinFactorization::lastRow
int * lastRow() const
Returns address of lastRow region.
Definition: CoinFactorization.hpp:167
CoinFactorization::gutsOfInitialize
void gutsOfInitialize(int type)
1 bit - tolerances etc, 2 more, 4 dummy arrays
CoinFactorization::maximumPivots
int maximumPivots() const
Maximum number of pivots between factorizations.
Definition: CoinFactorization.hpp:254
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::getColumnSpaceIterateR
bool getColumnSpaceIterateR(int iColumn, double value, int iRow)
getColumnSpaceIterateR.
CoinFactorization::updateColumnTransposeL
void updateColumnTransposeL(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL)
CoinFactorization::numberInRow_
CoinIntArrayWithLength numberInRow_
Number in each Row.
Definition: CoinFactorization.hpp:1359
CoinFactorization::setNumberElementsU
void setNumberElementsU(CoinBigIndex value)
Setss number in U area.
Definition: CoinFactorization.hpp:310
CoinFactorization::sort
void sort() const
Debug - sort so can compare.
CoinFactorizationDoubleArrayWithLength::array
CoinFactorizationDouble * array() const
Get Array.
Definition: CoinIndexedVector.hpp:682
COINFACTORIZATION_MASK_PER_INT
#define COINFACTORIZATION_MASK_PER_INT
Definition: CoinFactorization.hpp:809
CoinFactorization::updateColumnTransposeR
void updateColumnTransposeR(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR)
CoinBigIndexArrayWithLength::array
CoinBigIndex * array() const
Get Array.
Definition: CoinIndexedVector.hpp:844
CoinFactorization::elementL_
CoinFactorizationDoubleArrayWithLength elementL_
Elements of L.
Definition: CoinFactorization.hpp:1453
CoinFactorization::CoinFactorizationUnitTest
friend void CoinFactorizationUnitTest(const std::string &mpsDir)
COINFACTORIZATION_SHIFT_PER_INT
#define COINFACTORIZATION_SHIFT_PER_INT
Definition: CoinFactorization.hpp:808
CoinIndexedVector.hpp
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::indexRowR_
int * indexRowR_
Row indices for R.
Definition: CoinFactorization.hpp:1477
CoinFactorization::maximumRowsExtra
int maximumRowsExtra() const
Maximum of Rows after iterating.
Definition: CoinFactorization.hpp:215
CoinFactorization::lengthAreaR_
CoinBigIndex lengthAreaR_
length of area reserved for R
Definition: CoinFactorization.hpp:1471
CoinFactorization::slackValue_
double slackValue_
Whether slack value is +1 or -1.
Definition: CoinFactorization.hpp:1301
CoinFactorization::areaFactor
double areaFactor() const
Whether larger areas needed.
Definition: CoinFactorization.hpp:235
CoinFactorization::btranCountAfterL_
double btranCountAfterL_
Pivot tolerance.
Definition: CoinFactorization.hpp:1515
COIN_RESTRICT
#define COIN_RESTRICT
Definition: ClpMatrixBase.hpp:21
CoinFactorization::checkSparse
void checkSparse()
See if worth going sparse.
CoinFactorization::numberInColumn
int * numberInColumn() const
Number of entries in each column.
Definition: CoinFactorization.hpp:335
CoinFactorization::permute
int * permute() const
Returns address of permute region.
Definition: CoinFactorization.hpp:151
CoinFactorization::numberSlacks_
int numberSlacks_
Number of slacks at beginning of U.
Definition: CoinFactorization.hpp:1411
CoinFactorization::resetStatistics
void resetStatistics()
Reset all sparsity etc statistics.
CoinIndexedVector
Indexed Vector.
Definition: CoinIndexedVector.hpp:104
CoinFactorization::numberInRow
int * numberInRow() const
Number of entries in each row.
Definition: CoinFactorization.hpp:332
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::startColumnU_
CoinBigIndexArrayWithLength startColumnU_
Start of each column in U.
Definition: CoinFactorization.hpp:1435
CoinFactorization::setCollectStatistics
void setCollectStatistics(bool onOff) const
For statistics.
Definition: CoinFactorization.hpp:582
CoinFactorization::updateColumnRFT
void updateColumnRFT(CoinIndexedVector *region, int *indexIn)
Updates part of column (FTRANR) with FT update.
CoinFactorization::firstCount_
CoinIntArrayWithLength firstCount_
First Row/Column with count of k, can tell which by offset - Rows then Columns.
Definition: CoinFactorization.hpp:1369
CoinFactorization::getAreas
void getAreas(int numberRows, int numberColumns, CoinBigIndex maximumL, CoinBigIndex maximumU)
Gets space for a factorization, called by constructors.
CoinFactorization::numberElements
int numberElements() const
Total number of elements in factorization.
Definition: CoinFactorization.hpp:223
CoinFactorization::getAccuracyCheck
double getAccuracyCheck() const
Returns status.
Definition: CoinFactorization.hpp:246
CoinFactorization::btranCountInput_
double btranCountInput_
Pivot tolerance.
Definition: CoinFactorization.hpp:1512
CoinFactorization::btranCountAfterU_
double btranCountAfterU_
Pivot tolerance.
Definition: CoinFactorization.hpp:1513
CoinFactorization::numberU_
int numberU_
Number in U.
Definition: CoinFactorization.hpp:1414
CoinFactorization::factorSparseSmall
int factorSparseSmall()
Does sparse phase of factorization (for smaller problems) return code is &lt;0 error, 0= finished.
CoinFactorization::markRow_
CoinIntArrayWithLength markRow_
Marks rows to be updated.
Definition: CoinFactorization.hpp:1393
CoinFactorization::~CoinFactorization
~CoinFactorization()
Destructor.
CoinFactorization::factorize
int factorize(const CoinPackedMatrix &matrix, int rowIsBasic[], int columnIsBasic[], double areaFactor=0.0)
When part of LP - given by basic variables.
CoinFactorization::pivotRegion
CoinFactorizationDouble * pivotRegion() const
Returns address of pivot region.
Definition: CoinFactorization.hpp:159
CoinFactorization::cleanup
void cleanup()
Cleans up at end of factorization.
CoinFactorization::pivotRowL_
CoinIntArrayWithLength pivotRowL_
Pivots for L.
Definition: CoinFactorization.hpp:1405
CoinFactorization::lastRow_
CoinIntArrayWithLength lastRow_
Previous Row in memory order.
Definition: CoinFactorization.hpp:1387
CoinFactorization::numberPivots_
int numberPivots_
Number pivots since last factorization.
Definition: CoinFactorization.hpp:1330
CoinFactorization::permuteBack
int * permuteBack() const
Returns address of permuteBack region.
Definition: CoinFactorization.hpp:163
CoinFactorization::baseL_
CoinBigIndex baseL_
Base of L.
Definition: CoinFactorization.hpp:1444
CoinFactorization::denseThreshold_
int denseThreshold_
Dense threshold.
Definition: CoinFactorization.hpp:1495
CoinFactorization::startColumnL_
CoinBigIndexArrayWithLength startColumnL_
Start of each column in L.
Definition: CoinFactorization.hpp:1459
CoinFactorization::numberDense
int numberDense() const
Returns number of dense rows.
Definition: CoinFactorization.hpp:302
CoinFactorization::nextCount_
CoinIntArrayWithLength nextCount_
Next Row/Column with count.
Definition: CoinFactorization.hpp:1372
CoinFactorization::startColumnU
CoinBigIndex * startColumnU() const
Start of each column in U.
Definition: CoinFactorization.hpp:344
CoinFactorization::factor
int factor()
Does most of factorization.
CoinFactorization::startRowL
CoinBigIndex * startRowL() const
Start of each row in L.
Definition: CoinFactorization.hpp:177
CoinFactorization::separateLinks
void separateLinks(int count, bool rowsFirst)
Separate out links with same row/column count.
CoinFactorization::updateColumnL
void updateColumnL(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL)
CoinFactorization::status_
int status_
Status of factorization.
Definition: CoinFactorization.hpp:1345
CoinFactorization::updateColumnTransposeLByRow
void updateColumnTransposeLByRow(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by row.
CoinFactorization::numberRowsExtra
int numberRowsExtra() const
Number of Rows after iterating.
Definition: CoinFactorization.hpp:197
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...
CoinFactorization::factorSparseLarge
int factorSparseLarge()
Does sparse phase of factorization (for larger problems) return code is &lt;0 error, 0= finished...
CoinFactorization::numberFtranCounts_
int numberFtranCounts_
We can roll over factorizations.
Definition: CoinFactorization.hpp:1518
CoinTypes.hpp
CoinFactorization::pivots
int pivots() const
Returns number of pivots since factorization.
Definition: CoinFactorization.hpp:144
CoinFactorization::setPivots
void setPivots(int value)
Sets number of pivots since factorization.
Definition: CoinFactorization.hpp:148
CoinFactorization::numberInColumn_
CoinIntArrayWithLength numberInColumn_
Number in each Column.
Definition: CoinFactorization.hpp:1362
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::updateColumnR
void updateColumnR(CoinIndexedVector *region) const
Updates part of column (FTRANR) without FT update.
CoinFactorization::maximumCoefficient
double maximumCoefficient() const
Returns maximum absolute value in factorization.
CoinFactorization::areaFactor_
double areaFactor_
How much to multiply areas by.
Definition: CoinFactorization.hpp:1308
CoinFactorization::updateColumnU
void updateColumnU(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANU)
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::numberRows_
int numberRows_
Number of Rows in factorization.
Definition: CoinFactorization.hpp:1312
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::btranAverageAfterU_
double btranAverageAfterU_
Pivot tolerance.
Definition: CoinFactorization.hpp:1525
CoinFactorization::factorSparse
int factorSparse()
Does sparse phase of factorization return code is &lt;0 error, 0= finished.
CoinFactorization::status
int status() const
Returns status.
Definition: CoinFactorization.hpp:137
CoinFactorization::numberCompressions
CoinBigIndex numberCompressions() const
Number of compressions done.
Definition: CoinFactorization.hpp:329
CoinFactorization::numberGoodColumns
int numberGoodColumns() const
Number of good columns in factorization.
Definition: CoinFactorization.hpp:231
CoinFactorization::setDenseThreshold
void setDenseThreshold(int value)
Sets dense threshold.
Definition: CoinFactorization.hpp:263
CoinFactorization::convertRowToColumnU_
CoinBigIndexArrayWithLength convertRowToColumnU_
Converts rows to columns in U.
Definition: CoinFactorization.hpp:1438
CoinFactorization::checkPivot
int checkPivot(double saveFromU, double oldPivot) const
Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular. ...
CoinBigIndexArrayWithLength
CoinBigIndex * version.
Definition: CoinIndexedVector.hpp:835
CoinFactorization::updateColumnPFI
void updateColumnPFI(CoinIndexedVector *regionSparse) const
Updates part of column PFI (FTRAN) (after rest)
CoinFactorization::numberRows
int numberRows() const
Number of Rows after factorization.
Definition: CoinFactorization.hpp:204
CoinFactorization::emptyRows
void emptyRows(int numberToEmpty, const int which[])
Takes out all entries for given rows.
collectStatistics_
#define collectStatistics_
For statistics.
Definition: CoinFactorization.hpp:1534
CoinFactorization
This deals with Factorization and Updates.
Definition: CoinFactorization.hpp:50
CoinFactorization::numberGoodL_
int numberGoodL_
Number factorized in L.
Definition: CoinFactorization.hpp:1326
CoinFactorization::pivotTolerance
double pivotTolerance() const
Pivot tolerance.
Definition: CoinFactorization.hpp:266
CoinFactorization::btranAverageAfterL_
double btranAverageAfterL_
Pivot tolerance.
Definition: CoinFactorization.hpp:1527
CoinFactorization::permuteBack_
CoinIntArrayWithLength permuteBack_
DePermutation vector for pivot row order.
Definition: CoinFactorization.hpp:1341
CoinFactorization::restoreFactorization
int restoreFactorization(const char *file, bool factor=false)
Debug - restore from file - 0 if no error on file.
CoinFactorization::pivotTolerance_
double pivotTolerance_
Pivot tolerance.
Definition: CoinFactorization.hpp:1296
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::updateColumnTransposeRDensish
void updateColumnTransposeRDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when dense.
CoinFactorization::relaxCheck_
double relaxCheck_
Relax check on accuracy in replaceColumn.
Definition: CoinFactorization.hpp:1310
CoinFactorization::denseThreshold
int denseThreshold() const
Gets dense threshold.
Definition: CoinFactorization.hpp:260
CoinFactorization::lengthAreaL
CoinBigIndex lengthAreaL() const
Returns length of L area.
Definition: CoinFactorization.hpp:321
CoinFactorization::almostDestructor
void almostDestructor()
Delete all stuff (leaves as after CoinFactorization())
CoinFactorizationDoubleArrayWithLength
CoinFactorizationDouble * version.
Definition: CoinIndexedVector.hpp:673
CoinFactorization::setStatus
void setStatus(int value)
Sets status.
Definition: CoinFactorization.hpp:141
CoinFactorization::indexRowU_
CoinIntArrayWithLength indexRowU_
Row indices of U.
Definition: CoinFactorization.hpp:1432
CoinFactorization::doForrestTomlin_
bool doForrestTomlin_
true if Forrest Tomlin update, false if PFI
Definition: CoinFactorization.hpp:1462
CoinFactorization::lastColumn_
CoinIntArrayWithLength lastColumn_
Previous Column in memory order.
Definition: CoinFactorization.hpp:1381
CoinFactorization::relaxAccuracyCheck
void relaxAccuracyCheck(double value)
Allows change of pivot accuracy check 1.0 == none &gt;1.0 relaxed.
Definition: CoinFactorization.hpp:244
CoinFactorization::lengthL_
CoinBigIndex lengthL_
Length of L.
Definition: CoinFactorization.hpp:1447
CoinFactorization::messageLevel_
int messageLevel_
Detail in messages.
Definition: CoinFactorization.hpp:1396
CoinFactorization::saveFactorization
int saveFactorization(const char *file) const
Debug - save on file - 0 if no error.
CoinFactorization::show_self
void show_self() const
Debug show object (shows one representation)
CoinFactorization::maximumRowsExtra_
int maximumRowsExtra_
Maximum number of Rows after iterating.
Definition: CoinFactorization.hpp:1316
CoinFactorization::zeroTolerance
double zeroTolerance() const
Zero tolerance.
Definition: CoinFactorization.hpp:271
CoinFactorization::numberDense_
int numberDense_
Number of dense rows.
Definition: CoinFactorization.hpp:1492
CoinFactorization::messageLevel
int messageLevel() const
Level of detail of messages.
Definition: CoinFactorization.hpp:249
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::ftranAverageAfterR_
double ftranAverageAfterR_
Pivot tolerance.
Definition: CoinFactorization.hpp:1523
CoinFactorization::numberRowsExtra_
int numberRowsExtra_
Number of Rows after iterating.
Definition: CoinFactorization.hpp:1314
CoinFactorization::updateColumnLSparse
void updateColumnLSparse(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparse.
CoinFactorization::pivotColumnBack_
CoinIntArrayWithLength pivotColumnBack_
Inverse Pivot order for each Column.
Definition: CoinFactorization.hpp:1343
CoinFactorization::deleteLink
void deleteLink(int index)
Deletes a link in chain of equal counts.
Definition: CoinFactorization.hpp:685
CoinFactorization::elementByRowL_
CoinFactorizationDoubleArrayWithLength elementByRowL_
Elements in L (row copy)
Definition: CoinFactorization.hpp:1550
CoinFactorization::pivotColumnSingleton
bool pivotColumnSingleton(int pivotRow, int pivotColumn)
Does one pivot on Column Singleton in factorization.
CoinFactorization::numberR_
int numberR_
Number in R.
Definition: CoinFactorization.hpp:1465
CoinFactorization::densePermute_
int * densePermute_
Dense permutation.
Definition: CoinFactorization.hpp:1489
CoinFactorization::operator=
CoinFactorization & operator=(const CoinFactorization &other)
= copy
CoinFactorization::updateColumnLSparsish
void updateColumnLSparsish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparsish.
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::conditionNumber
double conditionNumber() const
Condition number - product of pivots after factorization.
CoinFactorization::updateColumnTransposeLSparsish
void updateColumnTransposeLSparsish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparsish 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::setForrestTomlin
void setForrestTomlin(bool value)
Returns status.
Definition: CoinFactorization.hpp:287
Generated by   doxygen 1.8.5