Scippy

SoPlex

Sequential object-oriented simPlex

CLUFactor Class Reference

Implementation of sparse LU factorization.This class implements a sparse LU factorization with either FOREST-TOMLIN or ETA updates, using dynamic Markowitz pivoting. More...

#include <clufactor.h>

Classes

struct  Dring
 
struct  L
 Data structures for saving the working matrix and L factor. More...
 
struct  Perm
 Data structures for saving the row and column permutations. More...
 
class  Pring
 Pivot Ring. More...
 
class  Temp
 Temporary data structures. More...
 
struct  U
 Data structures for saving the working matrix and U factor. More...
 

Protected Member Functions

Construction / destruction
 CLUFactor ()
 default construtor. More...
 
Solver methods
void solveLright (Real *vec)
 
int solveRight4update (Real *vec, int *nonz, Real eps, Real *rhs, Real *forest, int *forestNum, int *forestIdx)
 
void solveRight (Real *vec, Real *rhs)
 
int solveRight2update (Real *vec1, Real *vec2, Real *rhs1, Real *rhs2, int *nonz, Real eps, Real *forest, int *forestNum, int *forestIdx)
 
void solveRight2 (Real *vec1, Real *vec2, Real *rhs1, Real *rhs2)
 
void solveLeft (Real *vec, Real *rhs)
 
int solveLeftEps (Real *vec, Real *rhs, int *nonz, Real eps)
 
int solveLeft2 (Real *vec1, int *nonz, Real *vec2, Real eps, Real *rhs1, Real *rhs2)
 
int vSolveRight4update (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int rn, Real *forest, int *forestNum, int *forestIdx)
 
int vSolveRight4update2 (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int rn, Real *vec2, Real eps2, Real *rhs2, int *ridx2, int rn2, Real *forest, int *forestNum, int *forestIdx)
 
void vSolveRight4update2sparse (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int &rn, Real eps2, Real *vec2, int *idx2, Real *rhs2, int *ridx2, int &rn2, Real *forest, int *forestNum, int *forestIdx)
 sparse version of above method More...
 
int vSolveRight4update3 (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int rn, Real *vec2, Real eps2, Real *rhs2, int *ridx2, int rn2, Real *vec3, Real eps3, Real *rhs3, int *ridx3, int rn3, Real *forest, int *forestNum, int *forestIdx)
 
void vSolveRight4update3sparse (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int &rn, Real eps2, Real *vec2, int *idx2, Real *rhs2, int *ridx2, int &rn2, Real eps3, Real *vec3, int *idx3, Real *rhs3, int *ridx3, int &rn3, Real *forest, int *forestNum, int *forestIdx)
 sparse version of above method More...
 
void vSolveRightNoNZ (Real *vec, Real eps, Real *rhs, int *ridx, int rn)
 
int vSolveLeft (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int rn)
 
void vSolveLeftNoNZ (Real eps, Real *vec, Real *rhs, int *ridx, int rn)
 
int vSolveLeft2 (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int rn, Real *vec2, Real *rhs2, int *ridx2, int rn2)
 
void vSolveLeft2sparse (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int &rn, Real *vec2, int *idx2, Real *rhs2, int *ridx2, int &rn2)
 sparse version of solving 2 systems of equations More...
 
int vSolveLeft3 (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int rn, Real *vec2, Real *rhs2, int *ridx2, int rn2, Real *vec3, Real *rhs3, int *ridx3, int rn3)
 
void vSolveLeft3sparse (Real eps, Real *vec, int *idx, Real *rhs, int *ridx, int &rn, Real *vec2, int *idx2, Real *rhs2, int *ridx2, int &rn2, Real *vec3, int *idx3, Real *rhs3, int *ridx3, int &rn3)
 sparse version of solving 3 systems of equations More...
 
void forestUpdate (int col, Real *work, int num, int *nonz)
 Performs the Forrest-Tomlin update of the LU factorization. More...
 
void update (int p_col, Real *p_work, const int *p_idx, int num)
 
void updateNoClear (int p_col, const Real *p_work, const int *p_idx, int num)
 
void factor (const SVector **vec, Real threshold, Real eps)
 epsilon for zero detection More...
 
Debugging
void dump () const
 
bool isConsistent () const
 

Protected Attributes

Protected data
SLinSolver::Status stat
 Status indicator. More...
 
int thedim
 dimension of factorized matrix More...
 
int nzCnt
 number of nonzeros in U More...
 
Real initMaxabs
 maximum abs number in initail Matrix More...
 
Real maxabs
 maximum abs number in L and U More...
 
Real rowMemMult
 factor of minimum Memory * number of nonzeros More...
 
Real colMemMult
 factor of minimum Memory * number of nonzeros More...
 
Real lMemMult
 factor of minimum Memory * number of nonzeros More...
 
Perm row
 row permutation matrices More...
 
Perm col
 column permutation matrices More...
 
L l
 L matrix. More...
 
Realdiag
 Array of pivot elements. More...
 
U u
 U matrix. More...
 
Realwork
 Working array: must always be left as 0! More...
 
TimerfactorTime
 Time spent in factorizations. More...
 
int factorCount
 Number of factorizations. More...
 

Private Member Functions

Solving

These helper methods are used during the factorization process. The solve*-methods solve lower and upper triangular systems from the left or from the right, respectively The methods with '2' in the end solve two systems at the same time. The methods with "Eps" in the end consider elements smaller then the passed epsilon as zero.

void solveUright (Real *wrk, Real *vec) const
 
int solveUrightEps (Real *vec, int *nonz, Real eps, Real *rhs)
 
void solveUright2 (Real *work1, Real *vec1, Real *work2, Real *vec2)
 
int solveUright2eps (Real *work1, Real *vec1, Real *work2, Real *vec2, int *nonz, Real eps)
 
void solveLright2 (Real *vec1, Real *vec2)
 
void solveUpdateRight (Real *vec)
 
void solveUpdateRight2 (Real *vec1, Real *vec2)
 
void solveUleft (Real *work, Real *vec)
 
void solveUleft2 (Real *work1, Real *vec1, Real *work2, Real *vec2)
 
int solveLleft2forest (Real *vec1, int *, Real *vec2, Real)
 
void solveLleft2 (Real *vec1, int *, Real *vec2, Real)
 
int solveLleftForest (Real *vec, int *, Real)
 
void solveLleft (Real *vec) const
 
int solveLleftEps (Real *vec, int *nonz, Real eps)
 
void solveUpdateLeft (Real *vec)
 
void solveUpdateLeft2 (Real *vec1, Real *vec2)
 
void updateSolutionVectorLright (Real change, int j, Real &vec, int *idx, int &nnz)
 
void vSolveLright (Real *vec, int *ridx, int &rn, Real eps)
 
void vSolveLright2 (Real *vec, int *ridx, int &rn, Real eps, Real *vec2, int *ridx2, int &rn2, Real eps2)
 
void vSolveLright3 (Real *vec, int *ridx, int &rn, Real eps, Real *vec2, int *ridx2, int &rn2, Real eps2, Real *vec3, int *ridx3, int &rn3, Real eps3)
 
int vSolveUright (Real *vec, int *vidx, Real *rhs, int *ridx, int rn, Real eps)
 
void vSolveUrightNoNZ (Real *vec, Real *rhs, int *ridx, int rn, Real eps)
 
int vSolveUright2 (Real *vec, int *vidx, Real *rhs, int *ridx, int rn, Real eps, Real *vec2, Real *rhs2, int *ridx2, int rn2, Real eps2)
 
int vSolveUpdateRight (Real *vec, int *ridx, int n, Real eps)
 
void vSolveUpdateRightNoNZ (Real *vec, Real)
 
int solveUleft (Real eps, Real *vec, int *vecidx, Real *rhs, int *rhsidx, int rhsn)
 
void solveUleftNoNZ (Real eps, Real *vec, Real *rhs, int *rhsidx, int rhsn)
 
int solveLleftForest (Real eps, Real *vec, int *nonz, int n)
 
void solveLleftForestNoNZ (Real *vec)
 
int solveLleft (Real eps, Real *vec, int *nonz, int rn)
 
void solveLleftNoNZ (Real *vec)
 
int solveUpdateLeft (Real eps, Real *vec, int *nonz, int n)
 
void forestPackColumns ()
 
void forestMinColMem (int size)
 
void forestReMaxCol (int col, int len)
 
void initPerm ()
 
void initFactorMatrix (const SVector **vec, const Real eps)
 
void minLMem (int size)
 
void setPivot (const int p_stage, const int p_col, const int p_row, const Real val)
 
void colSingletons ()
 
void rowSingletons ()
 
void initFactorRings ()
 
void freeFactorRings ()
 
int setupColVals ()
 
void setupRowVals ()
 
void eliminateRowSingletons ()
 
void eliminateColSingletons ()
 
void selectPivots (Real threshold)
 
int updateRow (int r, int lv, int prow, int pcol, Real pval, Real eps)
 
void eliminatePivot (int prow, int pos, Real eps)
 
void eliminateNucleus (const Real eps, const Real threshold)
 
void minRowMem (int size)
 
void minColMem (int size)
 
void remaxCol (int p_col, int len)
 
void packRows ()
 
void packColumns ()
 
void remaxRow (int p_row, int len)
 
int makeLvec (int p_len, int p_row)
 
Blocked
 CLUFactor (const CLUFactor &)
 copy construtor. More...
 
CLUFactoroperator= (const CLUFactor &)
 assignment operator. More...
 

Private Attributes

Private data
Temp temp
 Temporary storage. More...
 

Detailed Description

Implementation of sparse LU factorization.

This class implements a sparse LU factorization with either FOREST-TOMLIN or ETA updates, using dynamic Markowitz pivoting.

Definition at line 37 of file clufactor.h.

Constructor & Destructor Documentation

◆ CLUFactor() [1/2]

CLUFactor ( const CLUFactor )
private

copy construtor.

◆ CLUFactor() [2/2]

Member Function Documentation

◆ colSingletons()

◆ dump()

◆ eliminateColSingletons()

◆ eliminateNucleus()

◆ eliminatePivot()

◆ eliminateRowSingletons()

◆ factor()

◆ forestMinColMem()

void forestMinColMem ( int  size)
private

◆ forestPackColumns()

◆ forestReMaxCol()

◆ forestUpdate()

void forestUpdate ( int  p_col,
Real p_work,
int  num,
int *  nonz 
)
protected

Performs the Forrest-Tomlin update of the LU factorization.

BH: I suppose this is implemented as described in UH Suhl, LM Suhl: A fast LU update for linear programming, Annals of OR 43, p. 33-47, 1993.

Parameters
p_colIndex of basis column to replace.
p_workDense vector to substitute in the basis.
numNumber of nonzeros in vector represented by p_work.
nonzIndices of nonzero elements in vector p_work.

The parameters num and nonz are used for the following optimization: If both are nonzero, indices of the nonzero elements provided in nonz (num giving their number) allow to access only those nonzero entries. Otherwise we have to go through the entire dense vector element by element.

After copying p_work into U, p_work is used to expand the row r, which is needed to restore the triangular structure of U.

Also num and nonz are used to maintain a heap if there are only very few nonzeros to be eliminated. This is plainly wrong if the method is called with nonz==0, see todo at the corresponding place below.

Exceptions
SPxStatusExceptionif the loaded matrix is singular
Todo:
Use an extra member variable as a buffer for working with the dense row instead of misusing p_work. I think that should be as efficient and much cleaner.

The following assert is obviously violated if this method is called with nonzero==0.

Todo:
Use an extra member variable as a buffer for the heap instead of misusing nonz and num. The method enQueueMin() seems to sort the nonzeros or something, for which it only needs some empty vector of size num.

Definition at line 710 of file clufactor.cpp.

References CLUFactor::U::col, CLUFactor::col, soplex::deQueueMin(), CLUFactor::diag, soplex::enQueueMin(), Param::epsilonUpdate(), CLUFactor::L::firstUnused, CLUFactor::forestReMaxCol(), CLUFactor::U::Row::idx, CLUFactor::U::Col::idx, CLUFactor::L::idx, CLUFactor::isConsistent(), soplex::isNotZero(), CLUFactor::l, CLUFactor::U::Row::len, CLUFactor::U::Col::len, CLUFactor::makeLvec(), CLUFactor::U::Row::max, CLUFactor::U::Col::max, CLUFactor::maxabs, CLUFactor::nzCnt, SLinSolver::OK, CLUFactor::Perm::orig, CLUFactor::Perm::perm, CLUFactor::remaxRow(), CLUFactor::U::row, CLUFactor::row, SLinSolver::SINGULAR, SOPLEX_FACTOR_MARKER, soplex::spxAbs(), CLUFactor::U::Row::start, CLUFactor::U::Col::start, CLUFactor::L::start, CLUFactor::stat, CLUFactor::thedim, CLUFactor::u, CLUFactor::U::Col::used, CLUFactor::U::Row::val, CLUFactor::U::Col::val, and CLUFactor::L::val.

Referenced by SLUFactor::change(), and CLUFactor::CLUFactor().

◆ freeFactorRings()

◆ initFactorMatrix()

◆ initFactorRings()

◆ initPerm()

void initPerm ( )
private

◆ isConsistent()

◆ makeLvec()

◆ minColMem()

void minColMem ( int  size)
private

◆ minLMem()

void minLMem ( int  size)
private

◆ minRowMem()

◆ operator=()

CLUFactor& operator= ( const CLUFactor )
private

assignment operator.

Referenced by CLUFactor::Pring::Pring().

◆ packColumns()

◆ packRows()

◆ remaxCol()

◆ remaxRow()

◆ rowSingletons()

◆ selectPivots()

◆ setPivot()

◆ setupColVals()

◆ setupRowVals()

◆ solveLeft()

◆ solveLeft2()

int solveLeft2 ( Real vec1,
int *  nonz,
Real vec2,
Real  eps,
Real rhs1,
Real rhs2 
)
protected

◆ solveLeftEps()

int solveLeftEps ( Real vec,
Real rhs,
int *  nonz,
Real  eps 
)
protected

◆ solveLleft() [1/2]

◆ solveLleft() [2/2]

◆ solveLleft2()

◆ solveLleft2forest()

int solveLleft2forest ( Real vec1,
int *  ,
Real vec2,
Real   
)
private

◆ solveLleftEps()

◆ solveLleftForest() [1/2]

◆ solveLleftForest() [2/2]

◆ solveLleftForestNoNZ()

◆ solveLleftNoNZ()

◆ solveLright()

◆ solveLright2()

◆ solveRight()

◆ solveRight2()

◆ solveRight2update()

int solveRight2update ( Real vec1,
Real vec2,
Real rhs1,
Real rhs2,
int *  nonz,
Real  eps,
Real forest,
int *  forestNum,
int *  forestIdx 
)
protected

◆ solveRight4update()

int solveRight4update ( Real vec,
int *  nonz,
Real  eps,
Real rhs,
Real forest,
int *  forestNum,
int *  forestIdx 
)
protected

◆ solveUleft() [1/2]

◆ solveUleft() [2/2]

◆ solveUleft2()

◆ solveUleftNoNZ()

◆ solveUpdateLeft() [1/2]

◆ solveUpdateLeft() [2/2]

◆ solveUpdateLeft2()

◆ solveUpdateRight()

◆ solveUpdateRight2()

◆ solveUright()

◆ solveUright2()

◆ solveUright2eps()

◆ solveUrightEps()

◆ update()

void update ( int  p_col,
Real p_work,
const int *  p_idx,
int  num 
)
protected

◆ updateNoClear()

void updateNoClear ( int  p_col,
const Real p_work,
const int *  p_idx,
int  num 
)
protected

◆ updateRow()

◆ updateSolutionVectorLright()

void updateSolutionVectorLright ( Real  change,
int  j,
Real vec,
int *  idx,
int &  nnz 
)
private

◆ vSolveLeft()

◆ vSolveLeft2()

int vSolveLeft2 ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int  rn,
Real vec2,
Real rhs2,
int *  ridx2,
int  rn2 
)
protected

◆ vSolveLeft2sparse()

void vSolveLeft2sparse ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int &  rn,
Real vec2,
int *  idx2,
Real rhs2,
int *  ridx2,
int &  rn2 
)
protected

◆ vSolveLeft3()

int vSolveLeft3 ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int  rn,
Real vec2,
Real rhs2,
int *  ridx2,
int  rn2,
Real vec3,
Real rhs3,
int *  ridx3,
int  rn3 
)
protected

◆ vSolveLeft3sparse()

void vSolveLeft3sparse ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int &  rn,
Real vec2,
int *  idx2,
Real rhs2,
int *  ridx2,
int &  rn2,
Real vec3,
int *  idx3,
Real rhs3,
int *  ridx3,
int &  rn3 
)
protected

◆ vSolveLeftNoNZ()

void vSolveLeftNoNZ ( Real  eps,
Real vec,
Real rhs,
int *  ridx,
int  rn 
)
protected

◆ vSolveLright()

◆ vSolveLright2()

◆ vSolveLright3()

void vSolveLright3 ( Real vec,
int *  ridx,
int &  rn,
Real  eps,
Real vec2,
int *  ridx2,
int &  rn2,
Real  eps2,
Real vec3,
int *  ridx3,
int &  rn3,
Real  eps3 
)
private

◆ vSolveRight4update()

int vSolveRight4update ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int  rn,
Real forest,
int *  forestNum,
int *  forestIdx 
)
protected

◆ vSolveRight4update2()

int vSolveRight4update2 ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int  rn,
Real vec2,
Real  eps2,
Real rhs2,
int *  ridx2,
int  rn2,
Real forest,
int *  forestNum,
int *  forestIdx 
)
protected

◆ vSolveRight4update2sparse()

void vSolveRight4update2sparse ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int &  rn,
Real  eps2,
Real vec2,
int *  idx2,
Real rhs2,
int *  ridx2,
int &  rn2,
Real forest,
int *  forestNum,
int *  forestIdx 
)
protected

◆ vSolveRight4update3()

int vSolveRight4update3 ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int  rn,
Real vec2,
Real  eps2,
Real rhs2,
int *  ridx2,
int  rn2,
Real vec3,
Real  eps3,
Real rhs3,
int *  ridx3,
int  rn3,
Real forest,
int *  forestNum,
int *  forestIdx 
)
protected

◆ vSolveRight4update3sparse()

void vSolveRight4update3sparse ( Real  eps,
Real vec,
int *  idx,
Real rhs,
int *  ridx,
int &  rn,
Real  eps2,
Real vec2,
int *  idx2,
Real rhs2,
int *  ridx2,
int &  rn2,
Real  eps3,
Real vec3,
int *  idx3,
Real rhs3,
int *  ridx3,
int &  rn3,
Real forest,
int *  forestNum,
int *  forestIdx 
)
protected

◆ vSolveRightNoNZ()

void vSolveRightNoNZ ( Real vec,
Real  eps,
Real rhs,
int *  ridx,
int  rn 
)
protected

◆ vSolveUpdateRight()

◆ vSolveUpdateRightNoNZ()

◆ vSolveUright()

◆ vSolveUright2()

int vSolveUright2 ( Real vec,
int *  vidx,
Real rhs,
int *  ridx,
int  rn,
Real  eps,
Real vec2,
Real rhs2,
int *  ridx2,
int  rn2,
Real  eps2 
)
private

◆ vSolveUrightNoNZ()

Member Data Documentation

◆ col

◆ colMemMult

Real colMemMult
protected

factor of minimum Memory * number of nonzeros

Definition at line 192 of file clufactor.h.

Referenced by SLUFactor::assign(), SLUFactor::clear(), CLUFactor::forestReMaxCol(), CLUFactor::initFactorMatrix(), and CLUFactor::remaxCol().

◆ diag

◆ factorCount

int factorCount
protected

Number of factorizations.

Definition at line 205 of file clufactor.h.

Referenced by CLUFactor::factor(), SLUFactor::getFactorCount(), SLUFactor::resetCounters(), and SLUFactor::SLUFactor().

◆ factorTime

◆ initMaxabs

Real initMaxabs
protected

maximum abs number in initail Matrix

Definition at line 188 of file clufactor.h.

Referenced by SLUFactor::assign(), SLUFactor::clear(), CLUFactor::initFactorMatrix(), and SLUFactor::stability().

◆ l

L l
protected

L matrix.

Definition at line 198 of file clufactor.h.

Referenced by SLUFactor::assign(), SLUFactor::change(), SLUFactor::clear(), CLUFactor::dump(), CLUFactor::eliminateRowSingletons(), CLUFactor::factor(), CLUFactor::forestUpdate(), SLUFactor::freeAll(), CLUFactor::isConsistent(), SLUFactor::load(), CLUFactor::makeLvec(), SLUFactor::memory(), CLUFactor::minLMem(), CLUFactor::rowSingletons(), CLUFactor::setupRowVals(), SLUFactor::SLUFactor(), SLUFactor::solve2right4update(), SLUFactor::solve3right4update(), CLUFactor::solveLeft(), CLUFactor::solveLeft2(), CLUFactor::solveLeftEps(), CLUFactor::solveLleft(), CLUFactor::solveLleft2(), CLUFactor::solveLleft2forest(), CLUFactor::solveLleftEps(), CLUFactor::solveLleftForest(), CLUFactor::solveLleftForestNoNZ(), CLUFactor::solveLleftNoNZ(), CLUFactor::solveLright(), CLUFactor::solveLright2(), CLUFactor::solveRight(), CLUFactor::solveRight2(), CLUFactor::solveRight2update(), SLUFactor::solveRight4update(), CLUFactor::solveRight4update(), CLUFactor::solveUpdateLeft(), CLUFactor::solveUpdateLeft2(), CLUFactor::solveUpdateRight(), CLUFactor::solveUpdateRight2(), CLUFactor::update(), CLUFactor::updateNoClear(), CLUFactor::updateRow(), CLUFactor::vSolveLeft(), CLUFactor::vSolveLeft2(), CLUFactor::vSolveLeft2sparse(), CLUFactor::vSolveLeft3(), CLUFactor::vSolveLeft3sparse(), CLUFactor::vSolveLeftNoNZ(), CLUFactor::vSolveLright(), CLUFactor::vSolveLright2(), CLUFactor::vSolveLright3(), CLUFactor::vSolveRight4update(), CLUFactor::vSolveRight4update2(), CLUFactor::vSolveRight4update2sparse(), CLUFactor::vSolveRight4update3(), CLUFactor::vSolveRight4update3sparse(), CLUFactor::vSolveRightNoNZ(), CLUFactor::vSolveUpdateRight(), and CLUFactor::vSolveUpdateRightNoNZ().

◆ lMemMult

Real lMemMult
protected

factor of minimum Memory * number of nonzeros

Definition at line 193 of file clufactor.h.

Referenced by SLUFactor::assign(), SLUFactor::clear(), and CLUFactor::initFactorMatrix().

◆ maxabs

◆ nzCnt

int nzCnt
protected

number of nonzeros in U

Definition at line 187 of file clufactor.h.

Referenced by SLUFactor::assign(), CLUFactor::factor(), CLUFactor::forestUpdate(), SLUFactor::memory(), and SLUFactor::SLUFactor().

◆ row

◆ rowMemMult

Real rowMemMult
protected

factor of minimum Memory * number of nonzeros

Definition at line 191 of file clufactor.h.

Referenced by SLUFactor::assign(), SLUFactor::clear(), CLUFactor::initFactorMatrix(), and CLUFactor::remaxRow().

◆ stat

◆ temp

◆ thedim

int thedim
protected

dimension of factorized matrix

Definition at line 186 of file clufactor.h.

Referenced by SLUFactor::assign(), SLUFactor::clear(), CLUFactor::colSingletons(), SLUFactor::dim(), CLUFactor::dump(), CLUFactor::eliminateNucleus(), CLUFactor::factor(), CLUFactor::forestPackColumns(), CLUFactor::forestUpdate(), CLUFactor::initFactorMatrix(), CLUFactor::initFactorRings(), CLUFactor::initPerm(), CLUFactor::isConsistent(), SLUFactor::load(), CLUFactor::packColumns(), CLUFactor::packRows(), CLUFactor::rowSingletons(), CLUFactor::selectPivots(), CLUFactor::setupColVals(), CLUFactor::setupRowVals(), SLUFactor::SLUFactor(), CLUFactor::solveLleft(), CLUFactor::solveLleft2(), CLUFactor::solveLleftEps(), CLUFactor::solveLleftForest(), CLUFactor::solveLleftForestNoNZ(), CLUFactor::solveLleftNoNZ(), CLUFactor::solveRight2(), CLUFactor::solveRight2update(), CLUFactor::solveRight4update(), CLUFactor::solveUleft(), CLUFactor::solveUleft2(), CLUFactor::solveUleftNoNZ(), CLUFactor::solveUpdateLeft(), CLUFactor::solveUright(), CLUFactor::solveUright2(), CLUFactor::solveUright2eps(), CLUFactor::solveUrightEps(), CLUFactor::updateSolutionVectorLright(), CLUFactor::vSolveLeft(), CLUFactor::vSolveLright(), CLUFactor::vSolveLright2(), CLUFactor::vSolveLright3(), CLUFactor::vSolveRight4update(), CLUFactor::vSolveRight4update2(), CLUFactor::vSolveRight4update2sparse(), CLUFactor::vSolveRight4update3(), CLUFactor::vSolveRight4update3sparse(), CLUFactor::vSolveRightNoNZ(), CLUFactor::vSolveUpdateRight(), CLUFactor::vSolveUpdateRightNoNZ(), CLUFactor::vSolveUright(), CLUFactor::vSolveUright2(), and CLUFactor::vSolveUrightNoNZ().

◆ u

◆ work

Real* work
protected

Working array: must always be left as 0!

Definition at line 202 of file clufactor.h.

Referenced by SLUFactor::assign(), CLUFactor::eliminatePivot(), SLUFactor::load(), SLUFactor::SLUFactor(), and CLUFactor::updateRow().