Cgl 0.60.2

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

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CoinSimpFactorization.hpp
Go to the documentation of this file.
1 /* $Id: CoinSimpFactorization.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
2 // Copyright (C) 2008, 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 This is a simple factorization of the LP Basis
8 */
9 #ifndef CoinSimpFactorization_H
10 #define CoinSimpFactorization_H
11
12 #include <iostream>
13 #include <string>
14 #include <cassert>
15 #include "CoinTypes.hpp"
16 #include "CoinIndexedVector.hpp"
17 #include "CoinDenseFactorization.hpp"
18 class CoinPackedMatrix;
19
21 class FactorPointers {
22 public:
23 double *rowMax;
24 int *firstRowKnonzeros;
25 int *prevRow;
26 int *nextRow;
27 int *firstColKnonzeros;
28 int *prevColumn;
29 int *nextColumn;
30 int *newCols;
31 //constructor
32 FactorPointers(int numRows, int numCols, int *UrowLengths_, int *UcolLengths_);
33 // destructor
34 ~FactorPointers();
35 };
36
37 class CoinSimpFactorization : public CoinOtherFactorization {
38 friend void CoinSimpFactorizationUnitTest(const std::string &mpsDir);
39
40 public:
43 CoinSimpFactorization();
46 CoinSimpFactorization(const CoinSimpFactorization &other);
47
49 virtual ~CoinSimpFactorization();
51 CoinSimpFactorization &operator=(const CoinSimpFactorization &other);
53 virtual CoinOtherFactorization *clone() const;
55
58 virtual void getAreas(int numberRows,
60 int numberColumns,
61 int maximumL,
62 int maximumU);
63
65 virtual void preProcess();
71 virtual int factor();
73 virtual void postProcess(const int *sequence, int *pivotVariable);
75 virtual void makeNonSingular(int *sequence, int numberColumns);
77
80 virtual inline int numberElements() const
82 {
83 return numberRows_ * (numberColumns_ + numberPivots_);
84 }
86 double maximumCoefficient() const;
88
91
99 virtual int replaceColumn(CoinIndexedVector *regionSparse,
100 int pivotRow,
101 double pivotCheck,
102 bool checkBeforeModifying = false,
103 double acceptablePivot = 1.0e-8);
105
116 virtual int updateColumnFT(CoinIndexedVector *regionSparse,
117 CoinIndexedVector *regionSparse2,
118 bool noPermute = false);
119
122 virtual int updateColumn(CoinIndexedVector *regionSparse,
123 CoinIndexedVector *regionSparse2,
124 bool noPermute = false) const;
126 virtual int updateTwoColumnsFT(CoinIndexedVector *regionSparse1,
127 CoinIndexedVector *regionSparse2,
128 CoinIndexedVector *regionSparse3,
129 bool noPermute = false);
131 int upColumn(CoinIndexedVector *regionSparse,
132 CoinIndexedVector *regionSparse2,
133 bool noPermute = false, bool save = false) const;
138 virtual int updateColumnTranspose(CoinIndexedVector *regionSparse,
139 CoinIndexedVector *regionSparse2) const;
141 int upColumnTranspose(CoinIndexedVector *regionSparse,
142 CoinIndexedVector *regionSparse2) const;
144
149 inline void clearArrays()
151 {
152 gutsOfDestructor();
153 }
155 inline int *indices() const
156 {
157 return reinterpret_cast< int * >(elements_ + numberRows_ * numberRows_);
158 }
160 virtual inline int *permute() const
161 {
162 return pivotRow_;
163 }
165
167 void gutsOfDestructor();
169 void gutsOfInitialize();
171 void gutsOfCopy(const CoinSimpFactorization &other);
172
174 void factorize(int numberOfRows,
175 int numberOfColumns,
176 const int colStarts[],
177 const int indicesRow[],
178 const double elements[]);
180 int mainLoopFactor(FactorPointers &pointers);
182 void copyLbyRows();
184 void copyUbyColumns();
186 int findPivot(FactorPointers &pointers, int &r, int &s, bool &ifSlack);
188 int findPivotShCol(FactorPointers &pointers, int &r, int &s);
190 int findPivotSimp(FactorPointers &pointers, int &r, int &s);
192 void GaussEliminate(FactorPointers &pointers, int &r, int &s);
194 int findShortRow(const int column, const int length, int &minRow,
195 int &minRowLength, FactorPointers &pointers);
197 int findShortColumn(const int row, const int length, int &minCol,
198 int &minColLength, FactorPointers &pointers);
200 double findMaxInRrow(const int row, FactorPointers &pointers);
202 void pivoting(const int pivotRow, const int pivotColumn,
203 const double invPivot, FactorPointers &pointers);
205 void updateCurrentRow(const int pivotRow, const int row,
206 const double multiplier, FactorPointers &pointers,
207 int &newNonZeros);
209 void increaseLsize();
211 void increaseRowSize(const int row, const int newSize);
213 void increaseColSize(const int column, const int newSize, const bool b);
215 void enlargeUrow(const int numNewElements);
217 void enlargeUcol(const int numNewElements, const bool b);
219 int findInRow(const int row, const int column);
221 int findInColumn(const int column, const int row);
223 void removeRowFromActSet(const int row, FactorPointers &pointers);
225 void removeColumnFromActSet(const int column, FactorPointers &pointers);
227 void allocateSpaceForU();
229 void allocateSomeArrays();
231 void initialSomeNumbers();
233 void Lxeqb(double *b) const;
235 void Lxeqb2(double *b1, double *b2) const;
237 void Uxeqb(double *b, double *sol) const;
239 void Uxeqb2(double *b1, double *sol1, double *sol2, double *b2) const;
241 void xLeqb(double *b) const;
243 void xUeqb(double *b, double *sol) const;
245 int LUupdate(int newBasicCol);
247 void newEta(int row, int numNewElements);
249 void copyRowPermutations();
251 void Hxeqb(double *b) const;
253 void Hxeqb2(double *b1, double *b2) const;
255 void xHeqb(double *b) const;
257 void ftran(double *b, double *sol, bool save) const;
259 void ftran2(double *b1, double *sol1, double *b2, double *sol2) const;
261 void btran(double *b, double *sol) const;
263
265 protected:
268 int checkPivot(double saveFromU, double oldPivot) const;
270 protected:
273 double *denseVector_;
276 double *workArea2_;
278 double *workArea3_;
280 int *vecLabels_;
282 int *indVector_;
283
285 double *auxVector_;
287 int *auxInd_;
288
290 double *vecKeep_;
292 int *indKeep_;
294 mutable int keepSize_;
295
297 int *LrowStarts_;
299 int *LrowLengths_;
301 double *Lrows_;
303 int *LrowInd_;
305 int LrowSize_;
307 int LrowCap_;
308
310 int *LcolStarts_;
312 int *LcolLengths_;
314 double *Lcolumns_;
316 int *LcolInd_;
318 int LcolSize_;
320 int LcolCap_;
321
323 int *UrowStarts_;
325 int *UrowLengths_;
326 #ifdef COIN_SIMP_CAPACITY
327 int *UrowCapacities_;
329 #endif
330 double *Urows_;
333 int *UrowInd_;
335 int UrowMaxCap_;
337 int UrowEnd_;
339 int firstRowInU_;
341 int lastRowInU_;
343 int *prevRowInU_;
345 int *nextRowInU_;
346
348 int *UcolStarts_;
350 int *UcolLengths_;
351 #ifdef COIN_SIMP_CAPACITY
352 int *UcolCapacities_;
354 #endif
355 double *Ucolumns_;
358 int *UcolInd_;
360 int *prevColInU_;
362 int *nextColInU_;
364 int firstColInU_;
366 int lastColInU_;
368 int UcolMaxCap_;
370 int UcolEnd_;
372 int *colSlack_;
373
375 double *invOfPivots_;
376
378 int *colOfU_;
380 int *colPosition_;
382 int *rowOfU_;
384 int *rowPosition_;
386 int *secRowOfU_;
388 int *secRowPosition_;
389
391 int *EtaPosition_;
393 int *EtaStarts_;
395 int *EtaLengths_;
397 int *EtaInd_;
399 double *Eta_;
401 int EtaSize_;
403 int lastEtaRow_;
405 int maxEtaRows_;
407 int EtaMaxCap_;
408
410 int minIncrease_;
412 double updateTol_;
414 bool doSuhlHeuristic_;
416 double maxU_;
418 double maxGrowth_;
420 double maxA_;
422 int pivotCandLimit_;
424 int numberSlacks_;
426 int firstNumberSlacks_;
428 };
429 #endif
430
431 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
432 */
CoinSimpFactorization::increaseRowSize
void increaseRowSize(const int row, const int newSize)
allocates more space for a row of U
CoinSimpFactorization::updateColumnFT
virtual int updateColumnFT(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2, bool noPermute=false)
Updates one column (FTRAN) from regionSparse2 Tries to do FT update number returned is negative if no...
CoinSimpFactorization::lastColInU_
int lastColInU_
last column in U
Definition: CoinSimpFactorization.hpp:366
CoinSimpFactorization::lastRowInU_
int lastRowInU_
last row in U
Definition: CoinSimpFactorization.hpp:341
CoinSimpFactorization::EtaStarts_
int * EtaStarts_
Starts of eta vectors.
Definition: CoinSimpFactorization.hpp:393
CoinSimpFactorization::factor
virtual int factor()
Does most of factorization returning status 0 - OK -99 - needs more memory -1 - singular - use number...
CoinSimpFactorization::pivotCandLimit_
int pivotCandLimit_
maximum number of candidates for pivot
Definition: CoinSimpFactorization.hpp:422
CoinSimpFactorization::enlargeUrow
void enlargeUrow(const int numNewElements)
allocates more space for rows of U
CoinSimpFactorization::LrowInd_
int * LrowInd_
indices in the rows of L
Definition: CoinSimpFactorization.hpp:303
CoinSimpFactorization::UcolLengths_
int * UcolLengths_
Lengths of the columns of U.
Definition: CoinSimpFactorization.hpp:350
CoinSimpFactorization::btran
void btran(double *b, double *sol) const
does BTRAN
CoinSimpFactorization::UrowLengths_
int * UrowLengths_
Lengths of the rows of U.
Definition: CoinSimpFactorization.hpp:325
CoinSimpFactorization::maxGrowth_
double maxGrowth_
bound on the growth rate
Definition: CoinSimpFactorization.hpp:418
CoinSimpFactorization::minIncrease_
int minIncrease_
minimum storage increase
Definition: CoinSimpFactorization.hpp:410
CoinSimpFactorization::Urows_
double * Urows_
U by rows.
Definition: CoinSimpFactorization.hpp:331
CoinSimpFactorization::ftran2
void ftran2(double *b1, double *sol1, double *b2, double *sol2) const
same as above but with two columns
CoinSimpFactorization::UrowMaxCap_
int UrowMaxCap_
maximum capacity of Urows
Definition: CoinSimpFactorization.hpp:335
FactorPointers::prevRow
int * prevRow
Definition: CoinSimpFactorization.hpp:25
CoinTypes.hpp
CoinSimpFactorization::postProcess
virtual void postProcess(const int *sequence, int *pivotVariable)
Does post processing on valid factorization - putting variables on correct rows.
CoinOtherFactorization
Abstract base class which also has some scalars so can be used from Dense or Simp.
Definition: CoinDenseFactorization.hpp:26
CoinOtherFactorization::numberPivots_
int numberPivots_
Number pivots since last factorization.
Definition: CoinDenseFactorization.hpp:277
CoinSimpFactorization::LcolLengths_
int * LcolLengths_
Lengths of the columns of L.
Definition: CoinSimpFactorization.hpp:312
CoinSimpFactorization::EtaSize_
int EtaSize_
number of elements in Eta_
Definition: CoinSimpFactorization.hpp:401
CoinSimpFactorization::UcolInd_
int * UcolInd_
Indices in the columns of U.
Definition: CoinSimpFactorization.hpp:358
FactorPointers
pointers used during factorization
Definition: CoinSimpFactorization.hpp:21
CoinSimpFactorization::allocateSomeArrays
void allocateSomeArrays()
allocates several working arrays
CoinSimpFactorization::maxEtaRows_
int maxEtaRows_
maximum number of eta vectors
Definition: CoinSimpFactorization.hpp:405
CoinSimpFactorization::factorize
void factorize(int numberOfRows, int numberOfColumns, const int colStarts[], const int indicesRow[], const double elements[])
calls factorization
CoinOtherFactorization::numberRows_
int numberRows_
Number of Rows in factorization.
Definition: CoinDenseFactorization.hpp:269
CoinSimpFactorization::workArea3_
double * workArea3_
work array
Definition: CoinSimpFactorization.hpp:278
CoinSimpFactorization::UcolMaxCap_
int UcolMaxCap_
maximum capacity of Ucolumns_
Definition: CoinSimpFactorization.hpp:368
CoinSimpFactorization::firstRowInU_
int firstRowInU_
first row in U
Definition: CoinSimpFactorization.hpp:339
CoinSimpFactorization::Uxeqb2
void Uxeqb2(double *b1, double *sol1, double *sol2, double *b2) const
same as above but with two rhs
CoinSimpFactorization::newEta
void newEta(int row, int numNewElements)
creates a new eta vector
CoinSimpFactorization::~CoinSimpFactorization
virtual ~CoinSimpFactorization()
Destructor.
CoinSimpFactorization::LrowLengths_
int * LrowLengths_
Lengths of the rows of L.
Definition: CoinSimpFactorization.hpp:299
CoinSimpFactorization::doSuhlHeuristic_
bool doSuhlHeuristic_
do Shul heuristic
Definition: CoinSimpFactorization.hpp:414
CoinSimpFactorization::gutsOfCopy
void gutsOfCopy(const CoinSimpFactorization &other)
The real work of copy.
CoinSimpFactorization::LcolStarts_
int * LcolStarts_
Starts of the columns of L.
Definition: CoinSimpFactorization.hpp:310
CoinOtherFactorization::numberRows
int numberRows() const
Number of Rows after factorization.
Definition: CoinDenseFactorization.hpp:73
FactorPointers::~FactorPointers
~FactorPointers()
CoinSimpFactorization::clearArrays
void clearArrays()
Get rid of all memory.
Definition: CoinSimpFactorization.hpp:150
CoinSimpFactorization::EtaInd_
int * EtaInd_
columns of eta vectors
Definition: CoinSimpFactorization.hpp:397
CoinSimpFactorization::prevColInU_
int * prevColInU_
previous column in U
Definition: CoinSimpFactorization.hpp:360
CoinSimpFactorization::secRowPosition_
int * secRowPosition_
position of row after permutation during LUupdate
Definition: CoinSimpFactorization.hpp:388
CoinSimpFactorization::GaussEliminate
void GaussEliminate(FactorPointers &pointers, int &r, int &s)
does Gauss elimination
CoinSimpFactorization::removeColumnFromActSet
void removeColumnFromActSet(const int column, FactorPointers &pointers)
declares a column inactive
CoinSimpFactorization::UcolStarts_
int * UcolStarts_
Starts of the columns of U.
Definition: CoinSimpFactorization.hpp:348
CoinSimpFactorization::updateTol_
double updateTol_
maximum size for the diagonal of U after update
Definition: CoinSimpFactorization.hpp:412
CoinSimpFactorization::UrowEnd_
int UrowEnd_
number of used places in Urows
Definition: CoinSimpFactorization.hpp:337
CoinSimpFactorization::rowPosition_
int * rowPosition_
position of row after permutation
Definition: CoinSimpFactorization.hpp:384
CoinSimpFactorization::gutsOfDestructor
void gutsOfDestructor()
The real work of destructor.
CoinSimpFactorization::findShortColumn
int findShortColumn(const int row, const int length, int &minCol, int &minColLength, FactorPointers &pointers)
finds short column that intersects a given row
CoinSimpFactorization::xHeqb
void xHeqb(double *b) const
solves x H = b
CoinSimpFactorization::findShortRow
int findShortRow(const int column, const int length, int &minRow, int &minRowLength, FactorPointers &pointers)
finds short row that intersects a given column
CoinSimpFactorization::LcolInd_
int * LcolInd_
indices in the columns of L
Definition: CoinSimpFactorization.hpp:316
CoinSimpFactorization::increaseLsize
void increaseLsize()
allocates more space for L
FactorPointers::FactorPointers
FactorPointers(int numRows, int numCols, int *UrowLengths_, int *UcolLengths_)
CoinSimpFactorization::workArea2_
double * workArea2_
work array
Definition: CoinSimpFactorization.hpp:276
CoinSimpFactorization::indices
int * indices() const
Returns array to put basis indices in.
Definition: CoinSimpFactorization.hpp:155
CoinSimpFactorization::Eta_
double * Eta_
elements of eta vectors
Definition: CoinSimpFactorization.hpp:399
CoinSimpFactorization::replaceColumn
virtual 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...
CoinSimpFactorization::Lcolumns_
double * Lcolumns_
L by columns.
Definition: CoinSimpFactorization.hpp:314
CoinSimpFactorization::ftran
void ftran(double *b, double *sol, bool save) const
does FTRAN
CoinOtherFactorization::elements_
CoinFactorizationDouble * elements_
Elements of factorization and updates length is maxR*maxR+maxSpace will always be long enough so can ...
Definition: CoinDenseFactorization.hpp:290
CoinSimpFactorization::invOfPivots_
double * invOfPivots_
inverse values of the elements of diagonal of U
Definition: CoinSimpFactorization.hpp:375
CoinSimpFactorization::upColumnTranspose
int upColumnTranspose(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const
does updateColumnTranspose, the other is a wrapper
CoinSimpFactorization::Lxeqb
void Lxeqb(double *b) const
solves L x = b
FactorPointers::prevColumn
int * prevColumn
Definition: CoinSimpFactorization.hpp:28
CoinSimpFactorization::LrowStarts_
int * LrowStarts_
Starts of the rows of L.
Definition: CoinSimpFactorization.hpp:297
CoinSimpFactorization::updateTwoColumnsFT
virtual int updateTwoColumnsFT(CoinIndexedVector *regionSparse1, CoinIndexedVector *regionSparse2, CoinIndexedVector *regionSparse3, bool noPermute=false)
does FTRAN on two columns
CoinOtherFactorization::elements
virtual CoinFactorizationDouble * elements() const
Returns array to put basis elements in.
CoinOtherFactorization::numberColumns
int numberColumns() const
Total number of columns in factorization.
Definition: CoinDenseFactorization.hpp:78
CoinSimpFactorization::keepSize_
int keepSize_
number of nonzeros
Definition: CoinSimpFactorization.hpp:294
CoinSimpFactorization::LUupdate
int LUupdate(int newBasicCol)
updates factorization after a Simplex iteration
CoinSimpFactorization::auxInd_
int * auxInd_
auxiliary vector
Definition: CoinSimpFactorization.hpp:287
CoinSimpFactorization::numberSlacks_
int numberSlacks_
number of slacks in basis
Definition: CoinSimpFactorization.hpp:424
CoinSimpFactorization::denseVector_
double * denseVector_
work array (should be initialized to zero)
Definition: CoinSimpFactorization.hpp:274
CoinSimpFactorization::EtaMaxCap_
int EtaMaxCap_
Capacity of Eta_.
Definition: CoinSimpFactorization.hpp:407
CoinIndexedVector
Indexed Vector.
Definition: CoinIndexedVector.hpp:104
CoinSimpFactorization::firstNumberSlacks_
int firstNumberSlacks_
number of slacks in irst basis
Definition: CoinSimpFactorization.hpp:426
FactorPointers::nextColumn
int * nextColumn
Definition: CoinSimpFactorization.hpp:29
CoinSimpFactorization::removeRowFromActSet
void removeRowFromActSet(const int row, FactorPointers &pointers)
declares a row inactive
FactorPointers::firstColKnonzeros
int * firstColKnonzeros
Definition: CoinSimpFactorization.hpp:27
CoinSimpFactorization::pivoting
void pivoting(const int pivotRow, const int pivotColumn, const double invPivot, FactorPointers &pointers)
does pivoting
CoinSimpFactorization::maximumCoefficient
double maximumCoefficient() const
Returns maximum absolute value in factorization.
CoinSimpFactorization::copyLbyRows
void copyLbyRows()
copies L by rows
CoinSimpFactorization::prevRowInU_
int * prevRowInU_
previous row in U
Definition: CoinSimpFactorization.hpp:343
CoinSimpFactorization::copyUbyColumns
void copyUbyColumns()
copies U by columns
CoinSimpFactorization::EtaPosition_
int * EtaPosition_
position of Eta vector
Definition: CoinSimpFactorization.hpp:391
CoinSimpFactorization::colSlack_
int * colSlack_
indicator of slack variables
Definition: CoinSimpFactorization.hpp:372
CoinSimpFactorization::gutsOfInitialize
void gutsOfInitialize()
The real work of constructor.
CoinSimpFactorization::Hxeqb
void Hxeqb(double *b) const
solves H x = b, where H is a product of eta matrices
CoinSimpFactorization::permute
virtual int * permute() const
Returns permute in.
Definition: CoinSimpFactorization.hpp:160
CoinSimpFactorization::CoinSimpFactorization
CoinSimpFactorization()
Default constructor.
CoinSimpFactorization::checkPivot
int checkPivot(double saveFromU, double oldPivot) const
CoinSimpFactorization::nextRowInU_
int * nextRowInU_
next row in U
Definition: CoinSimpFactorization.hpp:345
CoinSimpFactorization::makeNonSingular
virtual void makeNonSingular(int *sequence, int numberColumns)
Makes a non-singular basis by replacing variables.
CoinSimpFactorization::LrowSize_
int LrowSize_
Size of Lrows_;.
Definition: CoinSimpFactorization.hpp:305
CoinSimpFactorization::updateColumnTranspose
virtual int updateColumnTranspose(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const
Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - i...
FactorPointers::nextRow
int * nextRow
Definition: CoinSimpFactorization.hpp:26
CoinSimpFactorization::indKeep_
int * indKeep_
indices of this vector
Definition: CoinSimpFactorization.hpp:292
CoinSimpFactorization::Hxeqb2
void Hxeqb2(double *b1, double *b2) const
same as above but with two rhs
CoinSimpFactorization::updateCurrentRow
void updateCurrentRow(const int pivotRow, const int row, const double multiplier, FactorPointers &pointers, int &newNonZeros)
part of pivoting
CoinSimpFactorization::xLeqb
void xLeqb(double *b) const
solves x L = b
CoinSimpFactorization::LcolSize_
int LcolSize_
numbers of elements in L
Definition: CoinSimpFactorization.hpp:318
CoinSimpFactorization::numberElements
virtual int numberElements() const
Total number of elements in factorization.
Definition: CoinSimpFactorization.hpp:81
CoinPackedMatrix
Sparse Matrix Base Class.
Definition: CoinPackedMatrix.hpp:79
CoinSimpFactorization::findPivot
int findPivot(FactorPointers &pointers, int &r, int &s, bool &ifSlack)
finds a pivot element using Markowitz count
CoinSimpFactorization
Definition: CoinSimpFactorization.hpp:37
CoinSimpFactorization::allocateSpaceForU
void allocateSpaceForU()
allocates space for U
CoinSimpFactorization::maxA_
double maxA_
maximum of A
Definition: CoinSimpFactorization.hpp:420
CoinSimpFactorization::increaseColSize
void increaseColSize(const int column, const int newSize, const bool b)
allocates more space for a column of U
CoinSimpFactorization::indVector_
int * indVector_
array of indices
Definition: CoinSimpFactorization.hpp:282
CoinSimpFactorization::xUeqb
void xUeqb(double *b, double *sol) const
solves x U = b
CoinSimpFactorization::rowOfU_
int * rowOfU_
permutations of rows
Definition: CoinSimpFactorization.hpp:382
CoinSimpFactorization::vecKeep_
double * vecKeep_
vector to keep for LUupdate
Definition: CoinSimpFactorization.hpp:290
CoinSimpFactorization::findPivotShCol
int findPivotShCol(FactorPointers &pointers, int &r, int &s)
finds a pivot in a shortest column
CoinSimpFactorization::nextColInU_
int * nextColInU_
next column in U
Definition: CoinSimpFactorization.hpp:362
CoinSimpFactorization::colOfU_
int * colOfU_
permutation of columns
Definition: CoinSimpFactorization.hpp:378
CoinSimpFactorization::initialSomeNumbers
void initialSomeNumbers()
initializes some numbers
CoinSimpFactorization::UrowStarts_
int * UrowStarts_
Starts of the rows of U.
Definition: CoinSimpFactorization.hpp:323
CoinSimpFactorization::copyRowPermutations
void copyRowPermutations()
makes a copy of row permutations
CoinSimpFactorization::firstColInU_
int firstColInU_
first column in U
Definition: CoinSimpFactorization.hpp:364
CoinSimpFactorization::enlargeUcol
void enlargeUcol(const int numNewElements, const bool b)
allocates more space for columns of U
CoinSimpFactorization::clone
virtual CoinOtherFactorization * clone() const
Clone.
CoinSimpFactorization::vecLabels_
int * vecLabels_
array of labels (should be initialized to zero)
Definition: CoinSimpFactorization.hpp:280
CoinOtherFactorization::pivotRow_
int * pivotRow_
Pivot row.
Definition: CoinDenseFactorization.hpp:285
CoinSimpFactorization::findPivotSimp
int findPivotSimp(FactorPointers &pointers, int &r, int &s)
finds a pivot in the first column available
CoinSimpFactorization::findInRow
int findInRow(const int row, const int column)
finds a given row in a column
CoinSimpFactorization::upColumn
int upColumn(CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2, bool noPermute=false, bool save=false) const
does updatecolumn if save==true keeps column for replace column
CoinSimpFactorization::maxU_
double maxU_
maximum of U
Definition: CoinSimpFactorization.hpp:416
CoinIndexedVector.hpp
CoinOtherFactorization::pivotRow
virtual int * pivotRow() const
Returns pivot row.
CoinSimpFactorization::getAreas
virtual void getAreas(int numberRows, int numberColumns, int maximumL, int maximumU)
Gets space for a factorization.
CoinSimpFactorization::LcolCap_
int LcolCap_
maximum capacity of L
Definition: CoinSimpFactorization.hpp:320
CoinSimpFactorization::findInColumn
int findInColumn(const int column, const int row)
finds a given column in a row
CoinSimpFactorization::LrowCap_
int LrowCap_
Capacity of Lrows_.
Definition: CoinSimpFactorization.hpp:307
CoinSimpFactorization::Lxeqb2
void Lxeqb2(double *b1, double *b2) const
same as above but with two rhs
CoinSimpFactorization::Ucolumns_
double * Ucolumns_
U by columns.
Definition: CoinSimpFactorization.hpp:356
FactorPointers::rowMax
double * rowMax
Definition: CoinSimpFactorization.hpp:23
CoinSimpFactorization::EtaLengths_
int * EtaLengths_
Lengths of eta vectors.
Definition: CoinSimpFactorization.hpp:395
CoinSimpFactorization::secRowOfU_
int * secRowOfU_
permutations of rows during LUupdate
Definition: CoinSimpFactorization.hpp:386
FactorPointers::firstRowKnonzeros
int * firstRowKnonzeros
Definition: CoinSimpFactorization.hpp:24
CoinOtherFactorization::numberColumns_
int numberColumns_
Number of Columns in factorization.
Definition: CoinDenseFactorization.hpp:271
CoinSimpFactorization::updateColumn
virtual 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...
CoinSimpFactorization::Uxeqb
void Uxeqb(double *b, double *sol) const
solves U x = b
CoinSimpFactorization::preProcess
virtual void preProcess()
PreProcesses column ordered copy of basis.
CoinSimpFactorization::colPosition_
int * colPosition_
position of column after permutation
Definition: CoinSimpFactorization.hpp:380
CoinSimpFactorization::Lrows_
double * Lrows_
L by rows.
Definition: CoinSimpFactorization.hpp:301
CoinSimpFactorization::auxVector_
double * auxVector_
auxiliary vector
Definition: CoinSimpFactorization.hpp:285
FactorPointers::newCols
int * newCols
Definition: CoinSimpFactorization.hpp:30
CoinDenseFactorization.hpp
CoinSimpFactorization::UcolEnd_
int UcolEnd_
last used position in Ucolumns_
Definition: CoinSimpFactorization.hpp:370
CoinSimpFactorization::lastEtaRow_
int lastEtaRow_
last eta row
Definition: CoinSimpFactorization.hpp:403
CoinSimpFactorization::operator=
CoinSimpFactorization & operator=(const CoinSimpFactorization &other)
= copy
CoinSimpFactorization::UrowInd_
int * UrowInd_
Indices in the rows of U.
Definition: CoinSimpFactorization.hpp:333
CoinSimpFactorization::findMaxInRrow
double findMaxInRrow(const int row, FactorPointers &pointers)
finds maximum absolute value in a row
CoinSimpFactorization::mainLoopFactor
int mainLoopFactor(FactorPointers &pointers)
main loop of factorization
CoinSimpFactorization::CoinSimpFactorizationUnitTest
friend void CoinSimpFactorizationUnitTest(const std::string &mpsDir)