#include <CoinSimpFactorization.hpp>
Public Member Functions | |
void | gutsOfDestructor () |
The real work of destructor. | |
void | gutsOfInitialize () |
The real work of constructor. | |
void | gutsOfCopy (const CoinSimpFactorization &other) |
The real work of copy. | |
void | factorize (int numberOfRows, int numberOfColumns, const int colStarts[], const int indicesRow[], const double elements[]) |
calls factorization | |
int | mainLoopFactor (FactorPointers &pointers) |
main loop of factorization | |
void | copyLbyRows () |
copies L by rows | |
void | copyUbyColumns () |
copies U by columns | |
int | findPivot (FactorPointers &pointers, int &r, int &s, bool &ifSlack) |
finds a pivot element using Markowitz count | |
int | findPivotShCol (FactorPointers &pointers, int &r, int &s) |
finds a pivot in a shortest column | |
int | findPivotSimp (FactorPointers &pointers, int &r, int &s) |
finds a pivot in the first column available | |
void | GaussEliminate (FactorPointers &pointers, int &r, int &s) |
does Gauss elimination | |
int | findShortRow (const int column, const int length, int &minRow, int &minRowLength, FactorPointers &pointers) |
finds short row that intersects a given column | |
int | findShortColumn (const int row, const int length, int &minCol, int &minColLength, FactorPointers &pointers) |
finds short column that intersects a given row | |
double | findMaxInRrow (const int row, FactorPointers &pointers) |
finds maximum absolute value in a row | |
void | pivoting (const int pivotRow, const int pivotColumn, const double invPivot, FactorPointers &pointers) |
does pivoting | |
void | updateCurrentRow (const int pivotRow, const int row, const double multiplier, FactorPointers &pointers, int &newNonZeros) |
part of pivoting | |
void | increaseLsize () |
allocates more space for L | |
void | increaseRowSize (const int row, const int newSize) |
allocates more space for a row of U | |
void | increaseColSize (const int column, const int newSize, const bool b) |
allocates more space for a column of U | |
void | enlargeUrow (const int numNewElements) |
allocates more space for rows of U | |
void | enlargeUcol (const int numNewElements, const bool b) |
allocates more space for columns of U | |
int | findInRow (const int row, const int column) |
finds a given row in a column | |
int | findInColumn (const int column, const int row) |
finds a given column in a row | |
void | removeRowFromActSet (const int row, FactorPointers &pointers) |
declares a row inactive | |
void | removeColumnFromActSet (const int column, FactorPointers &pointers) |
declares a column inactive | |
void | allocateSpaceForU () |
allocates space for U | |
void | allocateSomeArrays () |
allocates several working arrays | |
void | initialSomeNumbers () |
initializes some numbers | |
void | Lxeqb (double *b) const |
solves L x = b | |
void | Lxeqb2 (double *b1, double *b2) const |
same as above but with two rhs | |
void | Uxeqb (double *b, double *sol) const |
solves U x = b | |
void | Uxeqb2 (double *b1, double *sol1, double *sol2, double *b2) const |
same as above but with two rhs | |
void | xLeqb (double *b) const |
solves x L = b | |
void | xUeqb (double *b, double *sol) const |
solves x U = b | |
int | LUupdate (int newBasicCol) |
updates factorization after a Simplex iteration | |
void | newEta (int row, int numNewElements) |
creates a new eta vector | |
void | copyRowPermutations () |
makes a copy of row permutations | |
void | Hxeqb (double *b) const |
solves H x = b, where H is a product of eta matrices | |
void | Hxeqb2 (double *b1, double *b2) const |
same as above but with two rhs | |
void | xHeqb (double *b) const |
solves x H = b | |
void | ftran (double *b, double *sol, bool save) const |
does FTRAN | |
void | ftran2 (double *b1, double *sol1, double *b2, double *sol2) const |
same as above but with two columns | |
void | btran (double *b, double *sol) const |
does BTRAN | |
Constructors and destructor and copy | |
CoinSimpFactorization () | |
Default constructor. | |
CoinSimpFactorization (const CoinSimpFactorization &other) | |
Copy constructor. | |
virtual | ~CoinSimpFactorization () |
Destructor. | |
CoinSimpFactorization & | operator= (const CoinSimpFactorization &other) |
= copy | |
virtual CoinSmallFactorization * | clone () const |
Clone. | |
Do factorization - public | |
virtual void | getAreas (int numberRows, int numberColumns, CoinBigIndex maximumL, CoinBigIndex maximumU) |
Gets space for a factorization. | |
virtual void | preProcess () |
PreProcesses column ordered copy of basis. | |
virtual int | factor () |
Does most of factorization returning status 0 - OK -99 - needs more memory -1 - singular - use numberGoodColumns and redo. | |
virtual void | postProcess (const int *sequence, int *pivotVariable) |
Does post processing on valid factorization - putting variables on correct rows. | |
virtual void | makeNonSingular (int *sequence, int numberColumns) |
Makes a non-singular basis by replacing variables. | |
general stuff such as status | |
virtual int | numberElements () const |
Total number of elements in factorization. | |
double | maximumCoefficient () const |
Returns maximum absolute value in factorization. | |
rank one updates which do exist | |
virtual int | replaceColumn (CoinIndexedVector *regionSparse, int pivotRow, double pivotCheck, bool checkBeforeModifying=false) |
Replaces one Column to basis, returns 0=OK, 1=Probably OK, 2=singular, 3=no room If checkBeforeModifying is true will do all accuracy checks before modifying factorization. | |
various uses of factorization (return code number elements) | |
which user may want to know about | |
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 room regionSparse starts as zero and is zero at end. | |
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 >=0. | |
virtual int | updateTwoColumnsFT (CoinIndexedVector *regionSparse1, CoinIndexedVector *regionSparse2, CoinIndexedVector *regionSparse3, bool noPermute=false) |
does FTRAN on two columns | |
int | upColumn (CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2, bool noPermute=false, bool save=false) const |
does updatecolumn if save==true keeps column for replace column | |
virtual int | updateColumnTranspose (CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const |
Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - if regionSparse2 packed on input - will be packed on output. | |
int | upColumnTranspose (CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const |
does updateColumnTranspose, the other is a wrapper | |
various uses of factorization | |
*** Below this user may not want to know about
which user may not want to know about (left over from my LP code) | |
void | clearArrays () |
Get rid of all memory. | |
int * | indices () const |
Returns array to put basis indices in. | |
virtual int * | permute () const |
Returns permute in. | |
Protected Member Functions | |
int | checkPivot (double saveFromU, double oldPivot) const |
--------------------------------------- | |
Protected Attributes | |
data | |
double * | denseVector_ |
work array (should be initialized to zero) | |
double * | workArea2_ |
work array | |
double * | workArea3_ |
work array | |
int * | vecLabels_ |
array of labels (should be initialized to zero) | |
int * | indVector_ |
array of indices | |
double * | auxVector_ |
auxiliary vector | |
int * | auxInd_ |
auxiliary vector | |
double * | vecKeep_ |
vector to keep for LUupdate | |
int * | indKeep_ |
indices of this vector | |
int | keepSize_ |
number of nonzeros | |
int * | LrowStarts_ |
Starts of the rows of L. | |
int * | LrowLengths_ |
Lengths of the rows of L. | |
double * | Lrows_ |
L by rows. | |
int * | LrowInd_ |
indices in the rows of L | |
int | LrowSize_ |
Size of Lrows_;. | |
int | LrowCap_ |
Capacity of Lrows_. | |
int * | LcolStarts_ |
Starts of the columns of L. | |
int * | LcolLengths_ |
Lengths of the columns of L. | |
double * | Lcolumns_ |
L by columns. | |
int * | LcolInd_ |
indices in the columns of L | |
int | LcolSize_ |
numbers of elements in L | |
int | LcolCap_ |
maximum capacity of L | |
int * | UrowStarts_ |
Starts of the rows of U. | |
int * | UrowLengths_ |
Lengths of the rows of U. | |
double * | Urows_ |
U by rows. | |
int * | UrowInd_ |
Indices in the rows of U. | |
int | UrowMaxCap_ |
maximum capacity of Urows | |
int | UrowEnd_ |
number of used places in Urows | |
int | firstRowInU_ |
first row in U | |
int | lastRowInU_ |
last row in U | |
int * | prevRowInU_ |
previous row in U | |
int * | nextRowInU_ |
next row in U | |
int * | UcolStarts_ |
Starts of the columns of U. | |
int * | UcolLengths_ |
Lengths of the columns of U. | |
double * | Ucolumns_ |
U by columns. | |
int * | UcolInd_ |
Indices in the columns of U. | |
int * | prevColInU_ |
previous column in U | |
int * | nextColInU_ |
next column in U | |
int | firstColInU_ |
first column in U | |
int | lastColInU_ |
last column in U | |
int | UcolMaxCap_ |
maximum capacity of Ucolumns_ | |
int | UcolEnd_ |
last used position in Ucolumns_ | |
int * | colSlack_ |
indicator of slack variables | |
double * | invOfPivots_ |
inverse values of the elements of diagonal of U | |
int * | colOfU_ |
permutation of columns | |
int * | colPosition_ |
position of column after permutation | |
int * | rowOfU_ |
permutations of rows | |
int * | rowPosition_ |
position of row after permutation | |
int * | secRowOfU_ |
permutations of rows during LUupdate | |
int * | secRowPosition_ |
position of row after permutation during LUupdate | |
int * | EtaPosition_ |
position of Eta vector | |
int * | EtaStarts_ |
Starts of eta vectors. | |
int * | EtaLengths_ |
Lengths of eta vectors. | |
int * | EtaInd_ |
columns of eta vectors | |
double * | Eta_ |
elements of eta vectors | |
int | EtaSize_ |
number of elements in Eta_ | |
int | lastEtaRow_ |
last eta row | |
int | maxEtaRows_ |
maximum number of eta vectors | |
int | EtaMaxCap_ |
Capacity of Eta_. | |
int | minIncrease_ |
minimum storage increase | |
double | updateTol_ |
maximum size for the diagonal of U after update | |
bool | doSuhlHeuristic_ |
do Shul heuristic | |
double | maxU_ |
maximum of U | |
double | maxGrowth_ |
bound on the growth rate | |
double | maxA_ |
maximum of A | |
int | pivotCandLimit_ |
maximum number of candidates for pivot | |
int | numberSlacks_ |
number of slacks in basis | |
int | firstNumberSlacks_ |
number of slacks in irst basis | |
Friends | |
void | CoinSimpFactorizationUnitTest (const std::string &mpsDir) |
Definition at line 38 of file CoinSimpFactorization.hpp.
CoinSimpFactorization::CoinSimpFactorization | ( | ) |
Default constructor.
CoinSimpFactorization::CoinSimpFactorization | ( | const CoinSimpFactorization & | other | ) |
Copy constructor.
virtual CoinSimpFactorization::~CoinSimpFactorization | ( | ) | [virtual] |
Destructor.
CoinSimpFactorization& CoinSimpFactorization::operator= | ( | const CoinSimpFactorization & | other | ) |
= copy
virtual CoinSmallFactorization* CoinSimpFactorization::clone | ( | ) | const [virtual] |
virtual void CoinSimpFactorization::getAreas | ( | int | numberRows, | |
int | numberColumns, | |||
CoinBigIndex | maximumL, | |||
CoinBigIndex | maximumU | |||
) | [virtual] |
virtual void CoinSimpFactorization::preProcess | ( | ) | [virtual] |
virtual int CoinSimpFactorization::factor | ( | ) | [virtual] |
Does most of factorization returning status 0 - OK -99 - needs more memory -1 - singular - use numberGoodColumns and redo.
Implements CoinSmallFactorization.
virtual void CoinSimpFactorization::postProcess | ( | const int * | sequence, | |
int * | pivotVariable | |||
) | [virtual] |
Does post processing on valid factorization - putting variables on correct rows.
Implements CoinSmallFactorization.
virtual void CoinSimpFactorization::makeNonSingular | ( | int * | sequence, | |
int | numberColumns | |||
) | [virtual] |
virtual int CoinSimpFactorization::numberElements | ( | ) | const [inline, virtual] |
Total number of elements in factorization.
Implements CoinSmallFactorization.
Definition at line 83 of file CoinSimpFactorization.hpp.
double CoinSimpFactorization::maximumCoefficient | ( | ) | const |
Returns maximum absolute value in factorization.
virtual int CoinSimpFactorization::replaceColumn | ( | CoinIndexedVector * | regionSparse, | |
int | pivotRow, | |||
double | pivotCheck, | |||
bool | checkBeforeModifying = false | |||
) | [virtual] |
Replaces one Column to basis, returns 0=OK, 1=Probably OK, 2=singular, 3=no room If checkBeforeModifying is true will do all accuracy checks before modifying factorization.
Whether to set this depends on speed considerations. You could just do this on first iteration after factorization and thereafter re-factorize partial update already in U
Implements CoinSmallFactorization.
virtual int CoinSimpFactorization::updateColumnFT | ( | CoinIndexedVector * | regionSparse, | |
CoinIndexedVector * | regionSparse2, | |||
bool | noPermute = false | |||
) | [virtual] |
Updates one column (FTRAN) from regionSparse2 Tries to do FT update number returned is negative if no room regionSparse starts as zero and is zero at end.
Note - if regionSparse2 packed on input - will be packed on output
Implements CoinSmallFactorization.
virtual int CoinSimpFactorization::updateColumn | ( | CoinIndexedVector * | regionSparse, | |
CoinIndexedVector * | regionSparse2, | |||
bool | noPermute = false | |||
) | const [virtual] |
This version has same effect as above with FTUpdate==false so number returned is always >=0.
Implements CoinSmallFactorization.
virtual int CoinSimpFactorization::updateTwoColumnsFT | ( | CoinIndexedVector * | regionSparse1, | |
CoinIndexedVector * | regionSparse2, | |||
CoinIndexedVector * | regionSparse3, | |||
bool | noPermute = false | |||
) | [virtual] |
int CoinSimpFactorization::upColumn | ( | CoinIndexedVector * | regionSparse, | |
CoinIndexedVector * | regionSparse2, | |||
bool | noPermute = false , |
|||
bool | save = false | |||
) | const |
does updatecolumn if save==true keeps column for replace column
virtual int CoinSimpFactorization::updateColumnTranspose | ( | CoinIndexedVector * | regionSparse, | |
CoinIndexedVector * | regionSparse2 | |||
) | const [virtual] |
Updates one column (BTRAN) from regionSparse2 regionSparse starts as zero and is zero at end Note - if regionSparse2 packed on input - will be packed on output.
Implements CoinSmallFactorization.
int CoinSimpFactorization::upColumnTranspose | ( | CoinIndexedVector * | regionSparse, | |
CoinIndexedVector * | regionSparse2 | |||
) | const |
does updateColumnTranspose, the other is a wrapper
void CoinSimpFactorization::clearArrays | ( | ) | [inline] |
int* CoinSimpFactorization::indices | ( | ) | const [inline, virtual] |
Returns array to put basis indices in.
Implements CoinSmallFactorization.
Definition at line 153 of file CoinSimpFactorization.hpp.
virtual int* CoinSimpFactorization::permute | ( | ) | const [inline, virtual] |
Returns permute in.
Implements CoinSmallFactorization.
Definition at line 156 of file CoinSimpFactorization.hpp.
void CoinSimpFactorization::gutsOfDestructor | ( | ) |
The real work of destructor.
void CoinSimpFactorization::gutsOfInitialize | ( | ) |
The real work of constructor.
void CoinSimpFactorization::gutsOfCopy | ( | const CoinSimpFactorization & | other | ) |
The real work of copy.
void CoinSimpFactorization::factorize | ( | int | numberOfRows, | |
int | numberOfColumns, | |||
const int | colStarts[], | |||
const int | indicesRow[], | |||
const double | elements[] | |||
) |
calls factorization
int CoinSimpFactorization::mainLoopFactor | ( | FactorPointers & | pointers | ) |
main loop of factorization
void CoinSimpFactorization::copyLbyRows | ( | ) |
copies L by rows
void CoinSimpFactorization::copyUbyColumns | ( | ) |
copies U by columns
int CoinSimpFactorization::findPivot | ( | FactorPointers & | pointers, | |
int & | r, | |||
int & | s, | |||
bool & | ifSlack | |||
) |
finds a pivot element using Markowitz count
int CoinSimpFactorization::findPivotShCol | ( | FactorPointers & | pointers, | |
int & | r, | |||
int & | s | |||
) |
finds a pivot in a shortest column
int CoinSimpFactorization::findPivotSimp | ( | FactorPointers & | pointers, | |
int & | r, | |||
int & | s | |||
) |
finds a pivot in the first column available
void CoinSimpFactorization::GaussEliminate | ( | FactorPointers & | pointers, | |
int & | r, | |||
int & | s | |||
) |
does Gauss elimination
int CoinSimpFactorization::findShortRow | ( | const int | column, | |
const int | length, | |||
int & | minRow, | |||
int & | minRowLength, | |||
FactorPointers & | pointers | |||
) |
finds short row that intersects a given column
int CoinSimpFactorization::findShortColumn | ( | const int | row, | |
const int | length, | |||
int & | minCol, | |||
int & | minColLength, | |||
FactorPointers & | pointers | |||
) |
finds short column that intersects a given row
double CoinSimpFactorization::findMaxInRrow | ( | const int | row, | |
FactorPointers & | pointers | |||
) |
finds maximum absolute value in a row
void CoinSimpFactorization::pivoting | ( | const int | pivotRow, | |
const int | pivotColumn, | |||
const double | invPivot, | |||
FactorPointers & | pointers | |||
) |
does pivoting
void CoinSimpFactorization::updateCurrentRow | ( | const int | pivotRow, | |
const int | row, | |||
const double | multiplier, | |||
FactorPointers & | pointers, | |||
int & | newNonZeros | |||
) |
part of pivoting
void CoinSimpFactorization::increaseLsize | ( | ) |
allocates more space for L
void CoinSimpFactorization::increaseRowSize | ( | const int | row, | |
const int | newSize | |||
) |
allocates more space for a row of U
void CoinSimpFactorization::increaseColSize | ( | const int | column, | |
const int | newSize, | |||
const bool | b | |||
) |
allocates more space for a column of U
void CoinSimpFactorization::enlargeUrow | ( | const int | numNewElements | ) |
allocates more space for rows of U
void CoinSimpFactorization::enlargeUcol | ( | const int | numNewElements, | |
const bool | b | |||
) |
allocates more space for columns of U
int CoinSimpFactorization::findInRow | ( | const int | row, | |
const int | column | |||
) |
finds a given row in a column
int CoinSimpFactorization::findInColumn | ( | const int | column, | |
const int | row | |||
) |
finds a given column in a row
void CoinSimpFactorization::removeRowFromActSet | ( | const int | row, | |
FactorPointers & | pointers | |||
) |
declares a row inactive
void CoinSimpFactorization::removeColumnFromActSet | ( | const int | column, | |
FactorPointers & | pointers | |||
) |
declares a column inactive
void CoinSimpFactorization::allocateSpaceForU | ( | ) |
allocates space for U
void CoinSimpFactorization::allocateSomeArrays | ( | ) |
allocates several working arrays
void CoinSimpFactorization::initialSomeNumbers | ( | ) |
initializes some numbers
void CoinSimpFactorization::Lxeqb | ( | double * | b | ) | const |
solves L x = b
void CoinSimpFactorization::Lxeqb2 | ( | double * | b1, | |
double * | b2 | |||
) | const |
same as above but with two rhs
void CoinSimpFactorization::Uxeqb | ( | double * | b, | |
double * | sol | |||
) | const |
solves U x = b
void CoinSimpFactorization::Uxeqb2 | ( | double * | b1, | |
double * | sol1, | |||
double * | sol2, | |||
double * | b2 | |||
) | const |
same as above but with two rhs
void CoinSimpFactorization::xLeqb | ( | double * | b | ) | const |
solves x L = b
void CoinSimpFactorization::xUeqb | ( | double * | b, | |
double * | sol | |||
) | const |
solves x U = b
int CoinSimpFactorization::LUupdate | ( | int | newBasicCol | ) |
updates factorization after a Simplex iteration
void CoinSimpFactorization::newEta | ( | int | row, | |
int | numNewElements | |||
) |
creates a new eta vector
void CoinSimpFactorization::copyRowPermutations | ( | ) |
makes a copy of row permutations
void CoinSimpFactorization::Hxeqb | ( | double * | b | ) | const |
solves H x = b, where H is a product of eta matrices
void CoinSimpFactorization::Hxeqb2 | ( | double * | b1, | |
double * | b2 | |||
) | const |
same as above but with two rhs
void CoinSimpFactorization::xHeqb | ( | double * | b | ) | const |
solves x H = b
void CoinSimpFactorization::ftran | ( | double * | b, | |
double * | sol, | |||
bool | save | |||
) | const |
does FTRAN
void CoinSimpFactorization::ftran2 | ( | double * | b1, | |
double * | sol1, | |||
double * | b2, | |||
double * | sol2 | |||
) | const |
same as above but with two columns
void CoinSimpFactorization::btran | ( | double * | b, | |
double * | sol | |||
) | const |
does BTRAN
int CoinSimpFactorization::checkPivot | ( | double | saveFromU, | |
double | oldPivot | |||
) | const [protected] |
---------------------------------------
Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular
void CoinSimpFactorizationUnitTest | ( | const std::string & | mpsDir | ) | [friend] |
double* CoinSimpFactorization::denseVector_ [protected] |
work array (should be initialized to zero)
Definition at line 272 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::workArea2_ [protected] |
double* CoinSimpFactorization::workArea3_ [protected] |
int* CoinSimpFactorization::vecLabels_ [protected] |
array of labels (should be initialized to zero)
Definition at line 278 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::indVector_ [protected] |
double* CoinSimpFactorization::auxVector_ [protected] |
int* CoinSimpFactorization::auxInd_ [protected] |
double* CoinSimpFactorization::vecKeep_ [protected] |
int* CoinSimpFactorization::indKeep_ [protected] |
int CoinSimpFactorization::keepSize_ [mutable, protected] |
int* CoinSimpFactorization::LrowStarts_ [protected] |
int* CoinSimpFactorization::LrowLengths_ [protected] |
double* CoinSimpFactorization::Lrows_ [protected] |
int* CoinSimpFactorization::LrowInd_ [protected] |
int CoinSimpFactorization::LrowSize_ [protected] |
int CoinSimpFactorization::LrowCap_ [protected] |
int* CoinSimpFactorization::LcolStarts_ [protected] |
int* CoinSimpFactorization::LcolLengths_ [protected] |
double* CoinSimpFactorization::Lcolumns_ [protected] |
int* CoinSimpFactorization::LcolInd_ [protected] |
int CoinSimpFactorization::LcolSize_ [protected] |
int CoinSimpFactorization::LcolCap_ [protected] |
int* CoinSimpFactorization::UrowStarts_ [protected] |
int* CoinSimpFactorization::UrowLengths_ [protected] |
double* CoinSimpFactorization::Urows_ [protected] |
int* CoinSimpFactorization::UrowInd_ [protected] |
int CoinSimpFactorization::UrowMaxCap_ [protected] |
int CoinSimpFactorization::UrowEnd_ [protected] |
int CoinSimpFactorization::firstRowInU_ [protected] |
int CoinSimpFactorization::lastRowInU_ [protected] |
int* CoinSimpFactorization::prevRowInU_ [protected] |
int* CoinSimpFactorization::nextRowInU_ [protected] |
int* CoinSimpFactorization::UcolStarts_ [protected] |
int* CoinSimpFactorization::UcolLengths_ [protected] |
double* CoinSimpFactorization::Ucolumns_ [protected] |
int* CoinSimpFactorization::UcolInd_ [protected] |
int* CoinSimpFactorization::prevColInU_ [protected] |
int* CoinSimpFactorization::nextColInU_ [protected] |
int CoinSimpFactorization::firstColInU_ [protected] |
int CoinSimpFactorization::lastColInU_ [protected] |
int CoinSimpFactorization::UcolMaxCap_ [protected] |
int CoinSimpFactorization::UcolEnd_ [protected] |
int* CoinSimpFactorization::colSlack_ [protected] |
double* CoinSimpFactorization::invOfPivots_ [protected] |
inverse values of the elements of diagonal of U
Definition at line 376 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::colOfU_ [protected] |
int* CoinSimpFactorization::colPosition_ [protected] |
int* CoinSimpFactorization::rowOfU_ [protected] |
int* CoinSimpFactorization::rowPosition_ [protected] |
int* CoinSimpFactorization::secRowOfU_ [protected] |
int* CoinSimpFactorization::secRowPosition_ [protected] |
position of row after permutation during LUupdate
Definition at line 389 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::EtaPosition_ [protected] |
int* CoinSimpFactorization::EtaStarts_ [protected] |
int* CoinSimpFactorization::EtaLengths_ [protected] |
int* CoinSimpFactorization::EtaInd_ [protected] |
double* CoinSimpFactorization::Eta_ [protected] |
int CoinSimpFactorization::EtaSize_ [protected] |
int CoinSimpFactorization::lastEtaRow_ [protected] |
int CoinSimpFactorization::maxEtaRows_ [protected] |
int CoinSimpFactorization::EtaMaxCap_ [protected] |
int CoinSimpFactorization::minIncrease_ [protected] |
double CoinSimpFactorization::updateTol_ [protected] |
maximum size for the diagonal of U after update
Definition at line 413 of file CoinSimpFactorization.hpp.
bool CoinSimpFactorization::doSuhlHeuristic_ [protected] |
double CoinSimpFactorization::maxU_ [protected] |
double CoinSimpFactorization::maxGrowth_ [protected] |
double CoinSimpFactorization::maxA_ [protected] |
int CoinSimpFactorization::pivotCandLimit_ [protected] |
int CoinSimpFactorization::numberSlacks_ [protected] |
int CoinSimpFactorization::firstNumberSlacks_ [protected] |