#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) | |
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 | |
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
Reimplemented from CoinSmallFactorization.
virtual CoinSmallFactorization* CoinSimpFactorization::clone | ( | ) | const [virtual] |
Clone.
Implements CoinSmallFactorization.
virtual void CoinSimpFactorization::getAreas | ( | int | numberRows, | |
int | numberColumns, | |||
CoinBigIndex | maximumL, | |||
CoinBigIndex | maximumU | |||
) | [virtual] |
Gets space for a factorization.
Implements CoinSmallFactorization.
virtual void CoinSimpFactorization::preProcess | ( | ) | [virtual] |
PreProcesses column ordered copy of basis.
Implements CoinSmallFactorization.
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] |
Makes a non-singular basis by replacing variables.
Implements CoinSmallFactorization.
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] |
does FTRAN on two columns
Implements CoinSmallFactorization.
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] |
Get rid of all memory.
Definition at line 150 of file CoinSimpFactorization.hpp.
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] |
work array
Definition at line 274 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::workArea3_ [protected] |
work array
Definition at line 276 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::vecLabels_ [protected] |
array of labels (should be initialized to zero)
Definition at line 278 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::indVector_ [protected] |
array of indices
Definition at line 280 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::auxVector_ [protected] |
auxiliary vector
Definition at line 283 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::auxInd_ [protected] |
auxiliary vector
Definition at line 285 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::vecKeep_ [protected] |
vector to keep for LUupdate
Definition at line 288 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::indKeep_ [protected] |
indices of this vector
Definition at line 290 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::keepSize_ [mutable, protected] |
number of nonzeros
Definition at line 292 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::LrowStarts_ [protected] |
Starts of the rows of L.
Definition at line 297 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::LrowLengths_ [protected] |
Lengths of the rows of L.
Definition at line 299 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::Lrows_ [protected] |
L by rows.
Definition at line 301 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::LrowInd_ [protected] |
indices in the rows of L
Definition at line 303 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::LrowSize_ [protected] |
Size of Lrows_;.
Definition at line 305 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::LrowCap_ [protected] |
Capacity of Lrows_.
Definition at line 307 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::LcolStarts_ [protected] |
Starts of the columns of L.
Definition at line 310 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::LcolLengths_ [protected] |
Lengths of the columns of L.
Definition at line 312 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::Lcolumns_ [protected] |
L by columns.
Definition at line 314 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::LcolInd_ [protected] |
indices in the columns of L
Definition at line 316 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::LcolSize_ [protected] |
numbers of elements in L
Definition at line 318 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::LcolCap_ [protected] |
maximum capacity of L
Definition at line 320 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::UrowStarts_ [protected] |
Starts of the rows of U.
Definition at line 324 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::UrowLengths_ [protected] |
Lengths of the rows of U.
Definition at line 326 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::Urows_ [protected] |
U by rows.
Definition at line 332 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::UrowInd_ [protected] |
Indices in the rows of U.
Definition at line 334 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::UrowMaxCap_ [protected] |
maximum capacity of Urows
Definition at line 336 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::UrowEnd_ [protected] |
number of used places in Urows
Definition at line 338 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::firstRowInU_ [protected] |
first row in U
Definition at line 340 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::lastRowInU_ [protected] |
last row in U
Definition at line 342 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::prevRowInU_ [protected] |
previous row in U
Definition at line 344 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::nextRowInU_ [protected] |
next row in U
Definition at line 346 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::UcolStarts_ [protected] |
Starts of the columns of U.
Definition at line 349 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::UcolLengths_ [protected] |
Lengths of the columns of U.
Definition at line 351 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::Ucolumns_ [protected] |
U by columns.
Definition at line 357 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::UcolInd_ [protected] |
Indices in the columns of U.
Definition at line 359 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::prevColInU_ [protected] |
previous column in U
Definition at line 361 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::nextColInU_ [protected] |
next column in U
Definition at line 363 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::firstColInU_ [protected] |
first column in U
Definition at line 365 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::lastColInU_ [protected] |
last column in U
Definition at line 367 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::UcolMaxCap_ [protected] |
maximum capacity of Ucolumns_
Definition at line 369 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::UcolEnd_ [protected] |
last used position in Ucolumns_
Definition at line 371 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::colSlack_ [protected] |
indicator of slack variables
Definition at line 373 of file CoinSimpFactorization.hpp.
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] |
permutation of columns
Definition at line 379 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::colPosition_ [protected] |
position of column after permutation
Definition at line 381 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::rowOfU_ [protected] |
permutations of rows
Definition at line 383 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::rowPosition_ [protected] |
position of row after permutation
Definition at line 385 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::secRowOfU_ [protected] |
permutations of rows during LUupdate
Definition at line 387 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::secRowPosition_ [protected] |
position of row after permutation during LUupdate
Definition at line 389 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::EtaPosition_ [protected] |
position of Eta vector
Definition at line 392 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::EtaStarts_ [protected] |
Starts of eta vectors.
Definition at line 394 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::EtaLengths_ [protected] |
Lengths of eta vectors.
Definition at line 396 of file CoinSimpFactorization.hpp.
int* CoinSimpFactorization::EtaInd_ [protected] |
columns of eta vectors
Definition at line 398 of file CoinSimpFactorization.hpp.
double* CoinSimpFactorization::Eta_ [protected] |
elements of eta vectors
Definition at line 400 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::EtaSize_ [protected] |
number of elements in Eta_
Definition at line 402 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::lastEtaRow_ [protected] |
last eta row
Definition at line 404 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::maxEtaRows_ [protected] |
maximum number of eta vectors
Definition at line 406 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::EtaMaxCap_ [protected] |
Capacity of Eta_.
Definition at line 408 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::minIncrease_ [protected] |
minimum storage increase
Definition at line 411 of file CoinSimpFactorization.hpp.
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] |
do Shul heuristic
Definition at line 415 of file CoinSimpFactorization.hpp.
double CoinSimpFactorization::maxU_ [protected] |
maximum of U
Definition at line 417 of file CoinSimpFactorization.hpp.
double CoinSimpFactorization::maxGrowth_ [protected] |
bound on the growth rate
Definition at line 419 of file CoinSimpFactorization.hpp.
double CoinSimpFactorization::maxA_ [protected] |
maximum of A
Definition at line 421 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::pivotCandLimit_ [protected] |
maximum number of candidates for pivot
Definition at line 423 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::numberSlacks_ [protected] |
number of slacks in basis
Definition at line 425 of file CoinSimpFactorization.hpp.
int CoinSimpFactorization::firstNumberSlacks_ [protected] |
number of slacks in irst basis
Definition at line 427 of file CoinSimpFactorization.hpp.