Public Member Functions | Protected Member Functions | Friends

CoinSimpFactorization Class Reference

#include <CoinSimpFactorization.hpp>

Inheritance diagram for CoinSimpFactorization:
Inheritance graph
[legend]
Collaboration diagram for CoinSimpFactorization:
Collaboration graph
[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.
CoinSimpFactorizationoperator= (const CoinSimpFactorization &other)
 = copy
virtual CoinOtherFactorizationclone () 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, double acceptablePivot=1.0e-8)
 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)

Detailed Description

Definition at line 39 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 CoinOtherFactorization* CoinSimpFactorization::clone (  )  const [virtual]

Clone.

Implements CoinOtherFactorization.

virtual void CoinSimpFactorization::getAreas ( int  numberRows,
int  numberColumns,
CoinBigIndex  maximumL,
CoinBigIndex  maximumU 
) [virtual]

Gets space for a factorization.

Implements CoinOtherFactorization.

virtual void CoinSimpFactorization::preProcess (  )  [virtual]

PreProcesses column ordered copy of basis.

Implements CoinOtherFactorization.

virtual int CoinSimpFactorization::factor (  )  [virtual]

Does most of factorization returning status 0 - OK -99 - needs more memory -1 - singular - use numberGoodColumns and redo.

Implements CoinOtherFactorization.

virtual void CoinSimpFactorization::postProcess ( const int *  sequence,
int *  pivotVariable 
) [virtual]

Does post processing on valid factorization - putting variables on correct rows.

Implements CoinOtherFactorization.

virtual void CoinSimpFactorization::makeNonSingular ( int *  sequence,
int  numberColumns 
) [virtual]

Makes a non-singular basis by replacing variables.

Implements CoinOtherFactorization.

virtual int CoinSimpFactorization::numberElements (  )  const [inline, virtual]

Total number of elements in factorization.

Implements CoinOtherFactorization.

Definition at line 84 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,
double  acceptablePivot = 1.0e-8 
) [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 CoinOtherFactorization.

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 CoinOtherFactorization.

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 CoinOtherFactorization.

virtual int CoinSimpFactorization::updateTwoColumnsFT ( CoinIndexedVector regionSparse1,
CoinIndexedVector regionSparse2,
CoinIndexedVector regionSparse3,
bool  noPermute = false 
) [virtual]

does FTRAN on two columns

Implements CoinOtherFactorization.

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 CoinOtherFactorization.

int CoinSimpFactorization::upColumnTranspose ( CoinIndexedVector regionSparse,
CoinIndexedVector regionSparse2 
) const

does updateColumnTranspose, the other is a wrapper

void CoinSimpFactorization::clearArrays (  )  [inline, virtual]

Get rid of all memory.

Reimplemented from CoinOtherFactorization.

Definition at line 152 of file CoinSimpFactorization.hpp.

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

Returns array to put basis indices in.

Implements CoinOtherFactorization.

Definition at line 155 of file CoinSimpFactorization.hpp.

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

Returns permute in.

Implements CoinOtherFactorization.

Definition at line 158 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


Friends And Related Function Documentation

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

Member Data Documentation

work array (should be initialized to zero)

Definition at line 274 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::workArea2_ [protected]

work array

Definition at line 276 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::workArea3_ [protected]

work array

Definition at line 278 of file CoinSimpFactorization.hpp.

array of labels (should be initialized to zero)

Definition at line 280 of file CoinSimpFactorization.hpp.

array of indices

Definition at line 282 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::auxVector_ [protected]

auxiliary vector

Definition at line 285 of file CoinSimpFactorization.hpp.

auxiliary vector

Definition at line 287 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::vecKeep_ [protected]

vector to keep for LUupdate

Definition at line 290 of file CoinSimpFactorization.hpp.

indices of this vector

Definition at line 292 of file CoinSimpFactorization.hpp.

int CoinSimpFactorization::keepSize_ [mutable, protected]

number of nonzeros

Definition at line 294 of file CoinSimpFactorization.hpp.

Starts of the rows of L.

Definition at line 299 of file CoinSimpFactorization.hpp.

Lengths of the rows of L.

Definition at line 301 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::Lrows_ [protected]

L by rows.

Definition at line 303 of file CoinSimpFactorization.hpp.

indices in the rows of L

Definition at line 305 of file CoinSimpFactorization.hpp.

Size of Lrows_;.

Definition at line 307 of file CoinSimpFactorization.hpp.

Capacity of Lrows_.

Definition at line 309 of file CoinSimpFactorization.hpp.

Starts of the columns of L.

Definition at line 312 of file CoinSimpFactorization.hpp.

Lengths of the columns of L.

Definition at line 314 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::Lcolumns_ [protected]

L by columns.

Definition at line 316 of file CoinSimpFactorization.hpp.

indices in the columns of L

Definition at line 318 of file CoinSimpFactorization.hpp.

numbers of elements in L

Definition at line 320 of file CoinSimpFactorization.hpp.

maximum capacity of L

Definition at line 322 of file CoinSimpFactorization.hpp.

Starts of the rows of U.

Definition at line 326 of file CoinSimpFactorization.hpp.

Lengths of the rows of U.

Definition at line 328 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::Urows_ [protected]

U by rows.

Definition at line 334 of file CoinSimpFactorization.hpp.

Indices in the rows of U.

Definition at line 336 of file CoinSimpFactorization.hpp.

maximum capacity of Urows

Definition at line 338 of file CoinSimpFactorization.hpp.

number of used places in Urows

Definition at line 340 of file CoinSimpFactorization.hpp.

first row in U

Definition at line 342 of file CoinSimpFactorization.hpp.

last row in U

Definition at line 344 of file CoinSimpFactorization.hpp.

previous row in U

Definition at line 346 of file CoinSimpFactorization.hpp.

next row in U

Definition at line 348 of file CoinSimpFactorization.hpp.

Starts of the columns of U.

Definition at line 351 of file CoinSimpFactorization.hpp.

Lengths of the columns of U.

Definition at line 353 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::Ucolumns_ [protected]

U by columns.

Definition at line 359 of file CoinSimpFactorization.hpp.

Indices in the columns of U.

Definition at line 361 of file CoinSimpFactorization.hpp.

previous column in U

Definition at line 363 of file CoinSimpFactorization.hpp.

next column in U

Definition at line 365 of file CoinSimpFactorization.hpp.

first column in U

Definition at line 367 of file CoinSimpFactorization.hpp.

last column in U

Definition at line 369 of file CoinSimpFactorization.hpp.

maximum capacity of Ucolumns_

Definition at line 371 of file CoinSimpFactorization.hpp.

last used position in Ucolumns_

Definition at line 373 of file CoinSimpFactorization.hpp.

indicator of slack variables

Definition at line 375 of file CoinSimpFactorization.hpp.

inverse values of the elements of diagonal of U

Definition at line 378 of file CoinSimpFactorization.hpp.

permutation of columns

Definition at line 381 of file CoinSimpFactorization.hpp.

position of column after permutation

Definition at line 383 of file CoinSimpFactorization.hpp.

permutations of rows

Definition at line 385 of file CoinSimpFactorization.hpp.

position of row after permutation

Definition at line 387 of file CoinSimpFactorization.hpp.

permutations of rows during LUupdate

Definition at line 389 of file CoinSimpFactorization.hpp.

position of row after permutation during LUupdate

Definition at line 391 of file CoinSimpFactorization.hpp.

position of Eta vector

Definition at line 394 of file CoinSimpFactorization.hpp.

Starts of eta vectors.

Definition at line 396 of file CoinSimpFactorization.hpp.

Lengths of eta vectors.

Definition at line 398 of file CoinSimpFactorization.hpp.

columns of eta vectors

Definition at line 400 of file CoinSimpFactorization.hpp.

double* CoinSimpFactorization::Eta_ [protected]

elements of eta vectors

Definition at line 402 of file CoinSimpFactorization.hpp.

number of elements in Eta_

Definition at line 404 of file CoinSimpFactorization.hpp.

last eta row

Definition at line 406 of file CoinSimpFactorization.hpp.

maximum number of eta vectors

Definition at line 408 of file CoinSimpFactorization.hpp.

Capacity of Eta_.

Definition at line 410 of file CoinSimpFactorization.hpp.

minimum storage increase

Definition at line 413 of file CoinSimpFactorization.hpp.

maximum size for the diagonal of U after update

Definition at line 415 of file CoinSimpFactorization.hpp.

do Shul heuristic

Definition at line 417 of file CoinSimpFactorization.hpp.

double CoinSimpFactorization::maxU_ [protected]

maximum of U

Definition at line 419 of file CoinSimpFactorization.hpp.

bound on the growth rate

Definition at line 421 of file CoinSimpFactorization.hpp.

double CoinSimpFactorization::maxA_ [protected]

maximum of A

Definition at line 423 of file CoinSimpFactorization.hpp.

maximum number of candidates for pivot

Definition at line 425 of file CoinSimpFactorization.hpp.

number of slacks in basis

Definition at line 427 of file CoinSimpFactorization.hpp.

number of slacks in irst basis

Definition at line 429 of file CoinSimpFactorization.hpp.


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