Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CoinFactorization.hpp
Go to the documentation of this file.
1 /* $Id: CoinFactorization.hpp 1767 2015-01-05 12:36:13Z forrest $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 /*
7  Authors
8 
9  John Forrest
10 
11  */
12 #ifndef CoinFactorization_H
13 #define CoinFactorization_H
14 //#define COIN_ONE_ETA_COPY 100
15 
16 #include <iostream>
17 #include <string>
18 #include <cassert>
19 #include <cstdio>
20 #include <cmath>
21 #include "CoinTypes.hpp"
22 #include "CoinIndexedVector.hpp"
23 
24 class CoinPackedMatrix;
51  friend void CoinFactorizationUnitTest( const std::string & mpsDir );
52 
53 public:
54 
60  CoinFactorization ( const CoinFactorization &other);
61 
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;
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,
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  }
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 
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 {
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  {
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  }
330  { return numberCompressions_;}
332  inline int * numberInRow() const
333  { return numberInRow_.array();}
335  inline int * numberInColumn() const
336  { return numberInColumn_.array();}
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;
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;
756  int smallestIndex) const;
760  int smallestIndex) const;
764  int smallestIndex) const;
767  void updateColumnTransposeUSparse ( CoinIndexedVector * region) const;
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,
817  unsigned int workArea2[],
818  int increment2,
819  T markRow[] ,
820  int largeInteger)
821 {
822  int *indexColumnU = indexColumnU_.array();
826  int *indexRowU = indexRowU_.array();
827  CoinBigIndex *startRowU = startRowU_.array();
828  int *numberInRow = numberInRow_.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
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 
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_;
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_;
1345  int status_;
1346 
1351  //int increasingRows_;
1352 
1357 
1360 
1363 
1366 
1370 
1373 
1376 
1379 
1382 
1385 
1388 
1391 
1394 
1397 
1400 
1403 
1406 
1409 
1412 
1415 
1418 
1420  //int baseU_;
1421 
1424 
1427 
1430 
1433 
1436 
1439 
1442 
1445 
1448 
1451 
1454 
1457 
1460 
1463 
1466 
1469 
1472 
1475 
1478 
1481 
1483  double * denseArea_;
1484 
1487 
1490 
1493 
1496 
1499 
1502 
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 
1528 protected:
1529 
1531 #if 0
1532  mutable bool collectStatistics_;
1533 #else
1534 #define collectStatistics_ 1
1535 #endif
1536 
1539 
1542 
1545 
1548 
1551 
1557  int biasLU_;
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 * array() const
Get Array.
CoinBigIndexArrayWithLength startRowU_
Start of each Row as pointer.
CoinBigIndex numberL_
Number in L.
int numberR_
Number in R.
CoinBigIndex factorElements_
Number of elements after factorization.
#define COINFACTORIZATION_BITS_PER_INT
CoinFactorizationDouble * elementU() const
Elements of U.
bool getColumnSpaceIterateR(int iColumn, double value, int iRow)
getColumnSpaceIterateR.
CoinIntArrayWithLength nextColumn_
Next Column in memory order.
bool pivotOneOtherRow(int pivotRow, int pivotColumn)
Pivots when just one other row so faster?
CoinBigIndex * startRowL() const
Start of each row in L.
CoinFactorizationDoubleArrayWithLength pivotRegion_
Inverses of pivot values.
void setPivots(int value)
Sets number of pivots since factorization.
void separateLinks(int count, bool rowsFirst)
Separate out links with same row/column count.
bool doForrestTomlin_
true if Forrest Tomlin update, false if PFI
CoinFactorizationDouble * pivotRegion() const
Returns address of pivot region.
int addColumn(CoinBigIndex numberElements, int indicesRow[], double elements[])
Adds one Column to basis, can increase size of basis.
void updateColumnTransposeLDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by column.
int numberFtranCounts_
We can roll over factorizations.
int numberPivots_
Number pivots since last factorization.
void updateColumnTransposeRSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when sparse.
double areaFactor() const
Whether larger areas needed.
int numberDense() const
Returns number of dense rows.
int maximumRowsExtra_
Maximum number of Rows after iterating.
int status() const
Returns status.
int denseThreshold() const
Gets dense threshold.
int maximumColumnsExtra()
Maximum number of Columns after iterating.
int sparseThreshold_
Below this use sparse technology - if 0 then no L row copy.
int * indexColumnL() const
Index of column in row for L.
void deleteLink(int index)
Deletes a link in chain of equal counts.
void checkSparse()
See if worth going sparse.
int * pivotColumn() const
Returns address of pivotColumn region (also used for permuting)
CoinBigIndex lengthAreaL() const
Returns length of L area.
CoinIntArrayWithLength lastColumn_
Previous Column in memory order.
CoinFactorizationDoubleArrayWithLength elementL_
Elements of L.
void setNumberRows(int value)
Set number of Rows after factorization.
bool collectStatistics() const
For statistics.
void setForrestTomlin(bool value)
void updateColumnTransposeUSparsish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when sparsish, assumes index is sorted i.e.
int status_
Status of factorization.
#define COINFACTORIZATION_SHIFT_PER_INT
void updateColumnTransposeR(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR)
CoinIntArrayWithLength pivotRowL_
Pivots for L.
CoinBigIndex * startColumnL() const
Start of each column in L.
bool pivotRowSingleton(int pivotRow, int pivotColumn)
Does one pivot on Row Singleton in factorization.
void relaxAccuracyCheck(double value)
Allows change of pivot accuracy check 1.0 == none &gt;1.0 relaxed.
void sort() const
Debug - sort so can compare.
int numberRows() const
Number of Rows after factorization.
~CoinFactorization()
Destructor.
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...
double maximumCoefficient() const
Returns maximum absolute value in factorization.
int * permute() const
Returns address of permute region.
int numberGoodU_
Number factorized in U (not row singletons)
CoinFactorization()
Default constructor.
int deleteRow(int Row)
Deletes one Row from basis, returns rank.
CoinBigIndexArrayWithLength startColumnR_
Start of columns for R.
int factorizePart1(int numberRows, int numberColumns, CoinBigIndex estimateNumberElements, int *indicesRow[], int *indicesColumn[], CoinFactorizationDouble *elements[], double areaFactor=0.0)
Two part version for maximum flexibility This part creates arrays for user to fill.
double * denseArea_
Dense area.
CoinIntArrayWithLength markRow_
Marks rows to be updated.
int numberRowsExtra() const
Number of Rows after iterating.
void gutsOfInitialize(int type)
1 bit - tolerances etc, 2 more, 4 dummy arrays
bool pivot(int pivotRow, int pivotColumn, CoinBigIndex pivotRowPosition, CoinBigIndex pivotColumnPosition, CoinFactorizationDouble work[], unsigned int workArea2[], int increment2, T markRow[], int largeInteger)
int numberElements() const
Total number of elements in factorization.
void updateColumnTransposeLByRow(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when densish by row.
int updateColumnTranspose(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const
Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - i...
int updateColumnFT(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2)
Updates one column (FTRAN) from regionSparse2 Tries to do FT update number returned is negative if no...
void updateColumnL(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL)
int numberColumns() const
Total number of columns in factorization.
double relaxCheck_
Relax check on accuracy in replaceColumn.
void updateTwoColumnsUDensish(int &numberNonZero1, double *COIN_RESTRICT region1, int *COIN_RESTRICT index1, int &numberNonZero2, double *COIN_RESTRICT region2, int *COIN_RESTRICT index2) const
Updates part of 2 columns (FTRANU) real work.
void cleanup()
Cleans up at end of factorization.
CoinBigIndex lengthR_
Length of R stuff.
bool getRowSpaceIterate(int iRow, int extraNeeded)
Gets space for one Row with given length while iterating, may have to do compression (returns True i...
int * numberInRow() const
Number of entries in each row.
int restoreFactorization(const char *file, bool factor=false)
Debug - restore from file - 0 if no error on file.
CoinFactorization & operator=(const CoinFactorization &other)
= copy
int * pivotColumnBack() const
Returns address of pivotColumnBack region (also used for permuting) Now uses firstCount to save memor...
void updateColumnTransposeRDensish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANR) when dense.
CoinBigIndex * startColumnU() const
Start of each column in U.
int checkPivot(double saveFromU, double oldPivot) const
Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular. ...
double zeroTolerance() const
Zero tolerance.
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...
CoinBigIndex maximumU_
Maximum space used in U.
void updateColumnTransposeLSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparse (by Row)
#define COIN_RESTRICT
double * denseAreaAddress_
Dense area - actually used (for alignment etc)
CoinBigIndex lengthU_
Base of U is always 0.
void updateColumnPFI(CoinIndexedVector *regionSparse) const
Updates part of column PFI (FTRAN) (after rest)
double pivotTolerance_
Pivot tolerance.
#define collectStatistics_
For statistics.
int updateTwoColumnsFT(CoinIndexedVector *regionSparse1, CoinIndexedVector *regionSparse2, CoinIndexedVector *regionSparse3, bool noPermuteRegion3=false)
Updates one column (FTRAN) from region2 Tries to do FT update number returned is negative if no room...
int saveFactorization(const char *file) const
Debug - save on file - 0 if no error.
void gutsOfCopy(const CoinFactorization &other)
int * numberInColumn() const
Number of entries in each column.
int factorSparse()
Does sparse phase of factorization return code is &lt;0 error, 0= finished.
int numberRowsExtra_
Number of Rows after iterating.
CoinBigIndex lengthL_
Length of L.
CoinIntArrayWithLength numberInColumn_
Number in each Column.
void updateColumnLSparse(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparse.
int sparseThreshold() const
get sparse threshold
int persistenceFlag_
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
int factor()
Does most of factorization.
void setPersistenceFlag(int value)
int numberGoodColumns() const
Number of good columns in factorization.
CoinFactorizationDouble * array() const
Get Array.
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...
double CoinFactorizationDouble
Definition: CoinTypes.hpp:57
int numberDense_
Number of dense rows.
void updateColumnLSparsish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when sparsish.
void addLink(int index, int count)
Adds a link in chain of equal counts.
void gutsOfDestructor(int type=1)
The real work of constructors etc 0 just scalars, 1 bit normal.
int deleteColumn(int Row)
Deletes one Column from basis, returns rank.
int * densePermute_
Dense permutation.
void updateColumnTransposePFI(CoinIndexedVector *region) const
Updates part of column transpose PFI (BTRAN) (before rest)
int messageLevel() const
Level of detail of messages.
CoinBigIndex numberElementsL() const
Returns number in L area.
double getAccuracyCheck() const
void setBiasLU(int value)
int pivots() const
Returns number of pivots since factorization.
CoinBigIndex * version.
Indexed Vector.
CoinIntArrayWithLength nextCount_
Next Row/Column with count.
CoinBigIndexArrayWithLength startRowL_
Start of each row in L.
bool pivotColumnSingleton(int pivotRow, int pivotColumn)
Does one pivot on Column Singleton in factorization.
void updateColumnTransposeLSparsish(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL) when sparsish by row.
CoinIntArrayWithLength lastRow_
Previous Row in memory order.
CoinBigIndexArrayWithLength startColumnL_
Start of each column in L.
void replaceColumnU(CoinIndexedVector *regionSparse, CoinBigIndex *deleted, int internalPivotRow)
Combines BtranU and delete elements If deleted is NULL then delete elements otherwise store where ele...
int denseThreshold_
Dense threshold.
void almostDestructor()
Delete all stuff (leaves as after CoinFactorization())
friend void CoinFactorizationUnitTest(const std::string &mpsDir)
#define COINFACTORIZATION_MASK_PER_INT
CoinIntArrayWithLength firstCount_
First Row/Column with count of k, can tell which by offset - Rows then Columns.
int * lastRow() const
Returns address of lastRow region.
void setNumberElementsU(CoinBigIndex value)
Setss number in U area.
CoinIntArrayWithLength sparse_
Sparse regions.
CoinFactorizationDouble * elementR_
Elements of R.
CoinBigIndex lengthAreaU_
Length of area reserved for U.
void updateColumnTransposeL(CoinIndexedVector *region) const
Updates part of column transpose (BTRANL)
void updateColumnRFT(CoinIndexedVector *region, int *indexIn)
Updates part of column (FTRANR) with FT update.
int * indexRowL() const
Row indices of L.
void setStatus(int value)
Sets status.
CoinBigIndex getColumnSpaceIterate(int iColumn, double value, int iRow)
getColumnSpaceIterate.
CoinBigIndex lengthAreaR_
length of area reserved for R
double ftranAverageAfterL_
While these are average ratios collected over last period.
CoinIntArrayWithLength pivotColumn_
Pivot order for each Column.
void show_self() const
Debug show object (shows one representation)
double zeroTolerance_
Zero tolerance.
int numberU_
Number in U.
int biggerDimension_
Larger of row and column size.
int addRow(CoinBigIndex numberElements, int indicesColumn[], double elements[])
Adds one Row to basis, can increase size of basis.
int biasLU_
L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias.
void resetStatistics()
Reset all sparsity etc statistics.
void areaFactor(double value)
CoinBigIndex lengthAreaU() const
Returns length of U area.
int maximumPivots() const
Maximum number of pivots between factorizations.
double adjustedAreaFactor() const
Returns areaFactor but adjusted for dense.
int factorSparseLarge()
Does sparse phase of factorization (for larger problems) return code is &lt;0 error, 0= finished...
CoinBigIndex numberL() const
Number in L.
double ftranCountInput_
Below are all to collect.
int numberTrials_
0 - no increasing rows - no permutations, 1 - no increasing rows but permutations 2 - increasing rows...
CoinBigIndexArrayWithLength convertRowToColumnU_
Converts rows to columns in U.
void updateColumnUSparsish(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparsish.
CoinIntArrayWithLength nextRow_
Next Row in memory order.
CoinFactorizationDoubleArrayWithLength elementU_
Elements of U.
double slackValue() const
Whether slack value is +1 or -1.
Sparse Matrix Base Class.
int factorizePart2(int permutation[], int exactNumberElements)
This is part two of factorization Arrays belong to factorization and were returned by part 1 If statu...
int numberColumns_
Number of Columns in factorization.
CoinIntArrayWithLength indexColumnU_
Base address for U (may change)
void updateColumnUSparse(CoinIndexedVector *regionSparse, int *indexIn) const
Updates part of column (FTRANU) when sparse.
CoinFactorizationDoubleArrayWithLength workArea_
First work area.
CoinIntArrayWithLength saveColumn_
Columns left to do in a single pivot.
int * indexRowR_
Row indices for R.
void clearArrays()
Get rid of all memory.
void updateColumnTransposeUDensish(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) when densish, assumes index is sorted i.e.
int factorDense()
Does dense phase of factorization return code is &lt;0 error, 0= finished.
CoinIntArrayWithLength numberInColumnPlus_
Number in each Column including pivoted.
int updateColumnUDensish(double *COIN_RESTRICT region, int *COIN_RESTRICT regionIndex) const
Updates part of column (FTRANU)
CoinIntArrayWithLength pivotColumnBack_
Inverse Pivot order for each Column.
CoinBigIndexArrayWithLength startColumnU_
Start of each column in U.
CoinBigIndex baseL_
Base of L.
CoinBigIndex numberElementsU() const
Returns number in U area.
CoinIntArrayWithLength permuteBack_
DePermutation vector for pivot row order.
double slackValue_
Whether slack value is +1 or -1.
void goSparse()
makes a row copy of L for speed and to allow very sparse problems
CoinFactorizationDouble * version.
CoinIntArrayWithLength indexColumnL_
Index of column in row for L.
int CoinBigIndex
CoinIntArrayWithLength indexRowL_
Row indices of L.
CoinBigIndex numberCompressions_
Number of compressions done.
CoinBigIndex lengthAreaL_
Length of area reserved for L.
CoinIntArrayWithLength permute_
Permutation vector for pivot row order.
int add(CoinBigIndex numberElements, int indicesRow[], int indicesColumn[], double elements[])
Adds given elements to Basis and updates factorization, can increase size of basis.
void updateColumnTransposeUSparse(CoinIndexedVector *region) const
Updates part of column transpose (BTRANU) when sparse, assumes index is sorted i.e.
int * indexRowU() const
Row indices of U.
CoinUnsignedIntArrayWithLength workArea2_
Second work area.
This deals with Factorization and Updates.
bool getColumnSpace(int iColumn, int extraNeeded)
Gets space for one Column with given length, may have to do compression (returns True if successful)...
void updateColumnR(CoinIndexedVector *region) const
Updates part of column (FTRANR) without FT update.
double areaFactor_
How much to multiply areas by.
void checkConsistency()
Checks that row and column copies look OK.
CoinBigIndex totalElements_
Number of elements in U (to go) or while iterating total overall.
int * array() const
Get Array.
void updateColumnU(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANU)
void updateColumnTransposeU(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU), assumes index is sorted i.e.
int numberSlacks_
Number of slacks at beginning of U.
int numberColumnsExtra_
Number of Columns after iterating.
void getAreas(int numberRows, int numberColumns, CoinBigIndex maximumL, CoinBigIndex maximumU)
Gets space for a factorization, called by constructors.
CoinIntArrayWithLength numberInRow_
Number in each Row.
int numberForrestTomlin() const
Length of FT vector.
void setDenseThreshold(int value)
Sets dense threshold.
int messageLevel_
Detail in messages.
CoinIntArrayWithLength lastCount_
Previous Row/Column with count.
void updateColumnTransposeUByColumn(CoinIndexedVector *region, int smallestIndex) const
Updates part of column transpose (BTRANU) by column assumes index is sorted i.e.
CoinFactorizationDouble * elementByRowL() const
Elements in L (row copy)
int maximumPivots_
Maximum number of pivots before factorization.
bool spaceForForrestTomlin() const
True if FT update and space.
bool reorderU()
Reorders U so contiguous and in order (if there is space) Returns true if it could.
void preProcess(int state, int possibleDuplicates=-1)
PreProcesses raw triplet data.
int maximumColumnsExtra_
Maximum number of Columns after iterating.
int maximumRowsExtra() const
Maximum of Rows after iterating.
int persistenceFlag() const
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
int biasLU() const
L to U bias 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias.
int sparseThreshold2_
And one for &quot;sparsish&quot;.
int numberGoodL_
Number factorized in L.
double conditionNumber() const
Condition number - product of pivots after factorization.
double pivotTolerance() const
Pivot tolerance.
CoinFactorizationDoubleArrayWithLength elementByRowL_
Elements in L (row copy)
int numberRows_
Number of Rows in factorization.
void setCollectStatistics(bool onOff) const
For statistics.
void updateColumnLDensish(CoinIndexedVector *region, int *indexIn) const
Updates part of column (FTRANL) when densish.
CoinBigIndex numberCompressions() const
Number of compressions done.
CoinBigIndex baseL() const
Base of L.
int replaceRow(int whichRow, int numberElements, const int indicesColumn[], const double elements[])
Replaces one Row in basis, At present assumes just a singleton on row is in basis returns 0=OK...
int factorSparseSmall()
Does sparse phase of factorization (for smaller problems) return code is &lt;0 error, 0= finished.
CoinIntArrayWithLength indexRowU_
Row indices of U.
bool forrestTomlin() const
true if Forrest Tomlin update, false if PFI
void emptyRows(int numberToEmpty, const int which[])
Takes out all entries for given rows.
int factorize(const CoinPackedMatrix &matrix, int rowIsBasic[], int columnIsBasic[], double areaFactor=0.0)
When part of LP - given by basic variables.
bool getRowSpace(int iRow, int extraNeeded)
Gets space for one Row with given length, may have to do compression (returns True if successful)...
CoinBigIndex numberElementsR() const
Returns number in R area.
int * permuteBack() const
Returns address of permuteBack region.