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

- Alphabetical List
- Class List
- Class Hierarchy
- Class Members

# CoinSimpFactorization Class Reference

`#include <CoinSimpFactorization.hpp>`

Inheritance diagram for CoinSimpFactorization:

[legend]
Collaboration diagram for CoinSimpFactorization:

[legend]
List of all members.

## 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
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
| Returns accuracy status of replaceColumn returns 0=OK, 1=Probably OK, 2=singular.
## 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)

## Detailed Description

Definition at line 38 of file CoinSimpFactorization.hpp.

## Constructor & Destructor Documentation

CoinSimpFactorization::CoinSimpFactorization | ( |  | ) |

Default constructor.

CoinSimpFactorization::CoinSimpFactorization | ( | const CoinSimpFactorization & | other | ) |

Copy constructor.

virtual CoinSimpFactorization::~CoinSimpFactorization | ( |  | ) | `[virtual]`

Destructor.

## Member Function Documentation

CoinSimpFactorization& CoinSimpFactorization::operator= | ( | const CoinSimpFactorization & | other | ) |

= copy

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.

References CoinSmallFactorization::numberColumns_, CoinSmallFactorization::numberPivots_, and CoinSmallFactorization::numberRows_.

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.

References gutsOfDestructor().

int* CoinSimpFactorization::indices | ( |  | ) | const`[inline, virtual]`

Returns array to put basis indices in.

Implements CoinSmallFactorization.

Definition at line 153 of file CoinSimpFactorization.hpp.

References CoinSmallFactorization::elements_, and CoinSmallFactorization::numberRows_.

virtual int* CoinSimpFactorization::permute | ( |  | ) | const`[inline, virtual]`

Returns permute in.

Implements CoinSmallFactorization.

Definition at line 156 of file CoinSimpFactorization.hpp.

References CoinSmallFactorization::pivotRow_.

void CoinSimpFactorization::gutsOfDestructor | ( |  | ) |

The real work of destructor.

Referenced by clearArrays().

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.

## Friends And Related Function Documentation

void CoinSimpFactorizationUnitTest | ( | const std::string & | mpsDir | ) | `[friend]`

## Member Data Documentation

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.

The documentation for this class was generated from the following file:

- /home/coin/SVN-release/Blis-0.91.0/CoinUtils/src/CoinSimpFactorization.hpp