|
Loading...
Searching...
No Matches
Implementation of sparse LU factorization.
More...
#include <clufactor.h>
|
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...
|
|
|
|
void | solveLright (R *vec) |
|
int | solveRight4update (R *vec, int *nonz, R eps, R *rhs, R *forest, int *forestNum, int *forestIdx) |
|
void | solveRight (R *vec, R *rhs) |
|
int | solveRight2update (R *vec1, R *vec2, R *rhs1, R *rhs2, int *nonz, R eps, R *forest, int *forestNum, int *forestIdx) |
|
void | solveRight2 (R *vec1, R *vec2, R *rhs1, R *rhs2) |
|
void | solveLeft (R *vec, R *rhs) |
|
int | solveLeftEps (R *vec, R *rhs, int *nonz, R eps) |
|
int | solveLeft2 (R *vec1, int *nonz, R *vec2, R eps, R *rhs1, R *rhs2) |
|
int | vSolveRight4update (R eps, R *vec, int *idx, R *rhs, int *ridx, int rn, R *forest, int *forestNum, int *forestIdx) |
|
int | vSolveRight4update2 (R eps, R *vec, int *idx, R *rhs, int *ridx, int rn, R *vec2, R eps2, R *rhs2, int *ridx2, int rn2, R *forest, int *forestNum, int *forestIdx) |
|
void | vSolveRight4update2sparse (R eps, R *vec, int *idx, R *rhs, int *ridx, int &rn, R eps2, R *vec2, int *idx2, R *rhs2, int *ridx2, int &rn2, R *forest, int *forestNum, int *forestIdx) |
| sparse version of above method
|
|
int | vSolveRight4update3 (R eps, R *vec, int *idx, R *rhs, int *ridx, int rn, R *vec2, R eps2, R *rhs2, int *ridx2, int rn2, R *vec3, R eps3, R *rhs3, int *ridx3, int rn3, R *forest, int *forestNum, int *forestIdx) |
|
void | vSolveRight4update3sparse (R eps, R *vec, int *idx, R *rhs, int *ridx, int &rn, R eps2, R *vec2, int *idx2, R *rhs2, int *ridx2, int &rn2, R eps3, R *vec3, int *idx3, R *rhs3, int *ridx3, int &rn3, R *forest, int *forestNum, int *forestIdx) |
| sparse version of above method
|
|
void | vSolveRightNoNZ (R *vec, R eps, R *rhs, int *ridx, int rn) |
|
int | vSolveLeft (R eps, R *vec, int *idx, R *rhs, int *ridx, int rn) |
|
void | vSolveLeftNoNZ (R eps, R *vec, R *rhs, int *ridx, int rn) |
|
int | vSolveLeft2 (R eps, R *vec, int *idx, R *rhs, int *ridx, int rn, R *vec2, R *rhs2, int *ridx2, int rn2) |
|
void | vSolveLeft2sparse (R eps, R *vec, int *idx, R *rhs, int *ridx, int &rn, R *vec2, int *idx2, R *rhs2, int *ridx2, int &rn2) |
| sparse version of solving 2 systems of equations
|
|
int | vSolveLeft3 (R eps, R *vec, int *idx, R *rhs, int *ridx, int rn, R *vec2, R *rhs2, int *ridx2, int rn2, R *vec3, R *rhs3, int *ridx3, int rn3) |
|
void | vSolveLeft3sparse (R eps, R *vec, int *idx, R *rhs, int *ridx, int &rn, R *vec2, int *idx2, R *rhs2, int *ridx2, int &rn2, R *vec3, int *idx3, R *rhs3, int *ridx3, int &rn3) |
| sparse version of solving 3 systems of equations
|
|
void | forestUpdate (int col, R *work, int num, int *nonz) |
|
void | update (int p_col, R *p_work, const int *p_idx, int num) |
|
void | updateNoClear (int p_col, const R *p_work, const int *p_idx, int num) |
|
void | factor (const SVectorBase< R > **vec, R threshold, R eps) |
| epsilon for zero detection
|
|
|
void | dump () const |
|
bool | isConsistent () const |
|
|
|
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 (R *wrk, R *vec) const |
|
int | solveUrightEps (R *vec, int *nonz, R eps, R *rhs) |
|
void | solveUright2 (R *work1, R *vec1, R *work2, R *vec2) |
|
int | solveUright2eps (R *work1, R *vec1, R *work2, R *vec2, int *nonz, R eps) |
|
void | solveLright2 (R *vec1, R *vec2) |
|
void | solveUpdateRight (R *vec) |
|
void | solveUpdateRight2 (R *vec1, R *vec2) |
|
void | solveUleft (R *work, R *vec) |
|
void | solveUleft2 (R *work1, R *vec1, R *work2, R *vec2) |
|
int | solveLleft2forest (R *vec1, int *, R *vec2, R) |
|
void | solveLleft2 (R *vec1, int *, R *vec2, R) |
|
int | solveLleftForest (R *vec, int *, R) |
|
void | solveLleft (R *vec) const |
|
int | solveLleftEps (R *vec, int *nonz, R eps) |
|
void | solveUpdateLeft (R *vec) |
|
void | solveUpdateLeft2 (R *vec1, R *vec2) |
|
void | updateSolutionVectorLright (R change, int j, R &vec, int *idx, int &nnz) |
|
void | vSolveLright (R *vec, int *ridx, int &rn, R eps) |
|
void | vSolveLright2 (R *vec, int *ridx, int &rn, R eps, R *vec2, int *ridx2, int &rn2, R eps2) |
|
void | vSolveLright3 (R *vec, int *ridx, int &rn, R eps, R *vec2, int *ridx2, int &rn2, R eps2, R *vec3, int *ridx3, int &rn3, R eps3) |
|
int | vSolveUright (R *vec, int *vidx, R *rhs, int *ridx, int rn, R eps) |
|
void | vSolveUrightNoNZ (R *vec, R *rhs, int *ridx, int rn, R eps) |
|
int | vSolveUright2 (R *vec, int *vidx, R *rhs, int *ridx, int rn, R eps, R *vec2, R *rhs2, int *ridx2, int rn2, R eps2) |
|
int | vSolveUpdateRight (R *vec, int *ridx, int n, R eps) |
|
void | vSolveUpdateRightNoNZ (R *vec, R) |
|
int | solveUleft (R eps, R *vec, int *vecidx, R *rhs, int *rhsidx, int rhsn) |
|
void | solveUleftNoNZ (R eps, R *vec, R *rhs, int *rhsidx, int rhsn) |
|
int | solveLleftForest (R eps, R *vec, int *nonz, int n) |
|
void | solveLleftForestNoNZ (R *vec) |
|
int | solveLleft (R eps, R *vec, int *nonz, int rn) |
|
void | solveLleftNoNZ (R *vec) |
|
int | solveUpdateLeft (R eps, R *vec, int *nonz, int n) |
|
void | forestPackColumns () |
|
void | forestMinColMem (int size) |
|
void | forestReMaxCol (int col, int len) |
|
void | initPerm () |
|
void | initFactorMatrix (const SVectorBase< R > **vec, const R eps) |
|
void | minLMem (int size) |
|
void | setPivot (const int p_stage, const int p_col, const int p_row, const R val) |
|
void | colSingletons () |
|
void | rowSingletons () |
|
void | initFactorRings () |
|
void | freeFactorRings () |
|
int | setupColVals () |
|
void | setupRowVals () |
|
void | eliminateRowSingletons () |
|
void | eliminateColSingletons () |
|
void | selectPivots (R threshold) |
|
int | updateRow (int r, int lv, int prow, int pcol, R pval, R eps) |
|
void | eliminatePivot (int prow, int pos, R eps) |
|
void | eliminateNucleus (const R eps, const R 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) |
|
template< class R>
class soplex::CLUFactor< R > 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 49 of file clufactor.h.
◆ colSingletons()
◆ dump()
◆ eliminateColSingletons()
void eliminateColSingletons |
( |
| ) |
|
|
private |
◆ eliminateNucleus()
◆ eliminatePivot()
◆ eliminateRowSingletons()
void eliminateRowSingletons |
( |
| ) |
|
|
private |
◆ factor()
epsilon for zero detection
- Parameters
-
vec | Array of column VectorBase<R> pointers |
threshold | pivoting threshold |
◆ forestMinColMem()
◆ forestPackColumns()
void forestPackColumns |
( |
| ) |
|
|
private |
◆ forestReMaxCol()
◆ forestUpdate()
◆ freeFactorRings()
◆ initFactorMatrix()
◆ initFactorRings()
◆ initPerm()
◆ isConsistent()
bool isConsistent |
( |
| ) |
const |
|
protected |
◆ makeLvec()
◆ minColMem()
◆ minLMem()
◆ minRowMem()
◆ packColumns()
◆ packRows()
◆ remaxCol()
◆ remaxRow()
◆ rowSingletons()
◆ selectPivots()
void selectPivots |
( |
R | threshold | ) |
|
|
private |
◆ setPivot()
◆ setupColVals()
◆ setupRowVals()
◆ solveLeft()
void solveLeft |
( |
R * | vec, |
|
|
R * | rhs ) |
|
protected |
◆ solveLeft2()
int solveLeft2 |
( |
R * | vec1, |
|
|
int * | nonz, |
|
|
R * | vec2, |
|
|
R | eps, |
|
|
R * | rhs1, |
|
|
R * | rhs2 ) |
|
protected |
◆ solveLeftEps()
int solveLeftEps |
( |
R * | vec, |
|
|
R * | rhs, |
|
|
int * | nonz, |
|
|
R | eps ) |
|
protected |
◆ solveLleft() [1/2]
void solveLleft |
( |
R * | vec | ) |
const |
|
private |
◆ solveLleft() [2/2]
◆ solveLleft2()
void solveLleft2 |
( |
R * | vec1, |
|
|
int * | , |
|
|
R * | vec2, |
|
|
R | ) |
|
private |
◆ solveLleft2forest()
int solveLleft2forest |
( |
R * | vec1, |
|
|
int * | , |
|
|
R * | vec2, |
|
|
R | ) |
|
private |
◆ solveLleftEps()
int solveLleftEps |
( |
R * | vec, |
|
|
int * | nonz, |
|
|
R | eps ) |
|
private |
◆ solveLleftForest() [1/2]
int solveLleftForest |
( |
R * | vec, |
|
|
int * | , |
|
|
R | ) |
|
private |
◆ solveLleftForest() [2/2]
int solveLleftForest |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | nonz, |
|
|
int | n ) |
|
private |
◆ solveLleftForestNoNZ()
void solveLleftForestNoNZ |
( |
R * | vec | ) |
|
|
private |
◆ solveLleftNoNZ()
void solveLleftNoNZ |
( |
R * | vec | ) |
|
|
private |
◆ solveLright()
void solveLright |
( |
R * | vec | ) |
|
|
protected |
◆ solveLright2()
void solveLright2 |
( |
R * | vec1, |
|
|
R * | vec2 ) |
|
private |
◆ solveRight()
void solveRight |
( |
R * | vec, |
|
|
R * | rhs ) |
|
protected |
◆ solveRight2()
void solveRight2 |
( |
R * | vec1, |
|
|
R * | vec2, |
|
|
R * | rhs1, |
|
|
R * | rhs2 ) |
|
protected |
◆ solveRight2update()
int solveRight2update |
( |
R * | vec1, |
|
|
R * | vec2, |
|
|
R * | rhs1, |
|
|
R * | rhs2, |
|
|
int * | nonz, |
|
|
R | eps, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
◆ solveRight4update()
int solveRight4update |
( |
R * | vec, |
|
|
int * | nonz, |
|
|
R | eps, |
|
|
R * | rhs, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
◆ solveUleft() [1/2]
void solveUleft |
( |
R * | work, |
|
|
R * | vec ) |
|
private |
◆ solveUleft() [2/2]
int solveUleft |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | vecidx, |
|
|
R * | rhs, |
|
|
int * | rhsidx, |
|
|
int | rhsn ) |
|
private |
◆ solveUleft2()
void solveUleft2 |
( |
R * | work1, |
|
|
R * | vec1, |
|
|
R * | work2, |
|
|
R * | vec2 ) |
|
private |
◆ solveUleftNoNZ()
void solveUleftNoNZ |
( |
R | eps, |
|
|
R * | vec, |
|
|
R * | rhs, |
|
|
int * | rhsidx, |
|
|
int | rhsn ) |
|
private |
◆ solveUpdateLeft() [1/2]
void solveUpdateLeft |
( |
R * | vec | ) |
|
|
private |
◆ solveUpdateLeft() [2/2]
int solveUpdateLeft |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | nonz, |
|
|
int | n ) |
|
private |
◆ solveUpdateLeft2()
void solveUpdateLeft2 |
( |
R * | vec1, |
|
|
R * | vec2 ) |
|
private |
◆ solveUpdateRight()
void solveUpdateRight |
( |
R * | vec | ) |
|
|
private |
◆ solveUpdateRight2()
void solveUpdateRight2 |
( |
R * | vec1, |
|
|
R * | vec2 ) |
|
private |
◆ solveUright()
void solveUright |
( |
R * | wrk, |
|
|
R * | vec ) const |
|
private |
◆ solveUright2()
void solveUright2 |
( |
R * | work1, |
|
|
R * | vec1, |
|
|
R * | work2, |
|
|
R * | vec2 ) |
|
private |
◆ solveUright2eps()
int solveUright2eps |
( |
R * | work1, |
|
|
R * | vec1, |
|
|
R * | work2, |
|
|
R * | vec2, |
|
|
int * | nonz, |
|
|
R | eps ) |
|
private |
◆ solveUrightEps()
int solveUrightEps |
( |
R * | vec, |
|
|
int * | nonz, |
|
|
R | eps, |
|
|
R * | rhs ) |
|
private |
◆ update()
◆ updateNoClear()
◆ updateRow()
◆ updateSolutionVectorLright()
void updateSolutionVectorLright |
( |
R | change, |
|
|
int | j, |
|
|
R & | vec, |
|
|
int * | idx, |
|
|
int & | nnz ) |
|
private |
◆ vSolveLeft()
◆ vSolveLeft2()
int vSolveLeft2 |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R * | vec2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int | rn2 ) |
|
protected |
◆ vSolveLeft2sparse()
void vSolveLeft2sparse |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int & | rn, |
|
|
R * | vec2, |
|
|
int * | idx2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int & | rn2 ) |
|
protected |
sparse version of solving 2 systems of equations
◆ vSolveLeft3()
int vSolveLeft3 |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R * | vec2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int | rn2, |
|
|
R * | vec3, |
|
|
R * | rhs3, |
|
|
int * | ridx3, |
|
|
int | rn3 ) |
|
protected |
◆ vSolveLeft3sparse()
void vSolveLeft3sparse |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int & | rn, |
|
|
R * | vec2, |
|
|
int * | idx2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int & | rn2, |
|
|
R * | vec3, |
|
|
int * | idx3, |
|
|
R * | rhs3, |
|
|
int * | ridx3, |
|
|
int & | rn3 ) |
|
protected |
sparse version of solving 3 systems of equations
◆ vSolveLeftNoNZ()
void vSolveLeftNoNZ |
( |
R | eps, |
|
|
R * | vec, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn ) |
|
protected |
◆ vSolveLright()
◆ vSolveLright2()
void vSolveLright2 |
( |
R * | vec, |
|
|
int * | ridx, |
|
|
int & | rn, |
|
|
R | eps, |
|
|
R * | vec2, |
|
|
int * | ridx2, |
|
|
int & | rn2, |
|
|
R | eps2 ) |
|
private |
◆ vSolveLright3()
void vSolveLright3 |
( |
R * | vec, |
|
|
int * | ridx, |
|
|
int & | rn, |
|
|
R | eps, |
|
|
R * | vec2, |
|
|
int * | ridx2, |
|
|
int & | rn2, |
|
|
R | eps2, |
|
|
R * | vec3, |
|
|
int * | ridx3, |
|
|
int & | rn3, |
|
|
R | eps3 ) |
|
private |
◆ vSolveRight4update()
int vSolveRight4update |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
◆ vSolveRight4update2()
int vSolveRight4update2 |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R * | vec2, |
|
|
R | eps2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int | rn2, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
◆ vSolveRight4update2sparse()
void vSolveRight4update2sparse |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int & | rn, |
|
|
R | eps2, |
|
|
R * | vec2, |
|
|
int * | idx2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int & | rn2, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
sparse version of above method
◆ vSolveRight4update3()
int vSolveRight4update3 |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R * | vec2, |
|
|
R | eps2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int | rn2, |
|
|
R * | vec3, |
|
|
R | eps3, |
|
|
R * | rhs3, |
|
|
int * | ridx3, |
|
|
int | rn3, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
◆ vSolveRight4update3sparse()
void vSolveRight4update3sparse |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int & | rn, |
|
|
R | eps2, |
|
|
R * | vec2, |
|
|
int * | idx2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int & | rn2, |
|
|
R | eps3, |
|
|
R * | vec3, |
|
|
int * | idx3, |
|
|
R * | rhs3, |
|
|
int * | ridx3, |
|
|
int & | rn3, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
sparse version of above method
◆ vSolveRightNoNZ()
void vSolveRightNoNZ |
( |
R * | vec, |
|
|
R | eps, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn ) |
|
protected |
◆ vSolveUpdateRight()
int vSolveUpdateRight |
( |
R * | vec, |
|
|
int * | ridx, |
|
|
int | n, |
|
|
R | eps ) |
|
private |
◆ vSolveUpdateRightNoNZ()
void vSolveUpdateRightNoNZ |
( |
R * | vec, |
|
|
R | ) |
|
private |
◆ vSolveUright()
int vSolveUright |
( |
R * | vec, |
|
|
int * | vidx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R | eps ) |
|
private |
◆ vSolveUright2()
int vSolveUright2 |
( |
R * | vec, |
|
|
int * | vidx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R | eps, |
|
|
R * | vec2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int | rn2, |
|
|
R | eps2 ) |
|
private |
◆ vSolveUrightNoNZ()
void vSolveUrightNoNZ |
( |
R * | vec, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R | eps ) |
|
private |
◆ col
column permutation matrices
Definition at line 208 of file clufactor.h.
◆ colMemMult
factor of minimum Memory * number of nonzeros
Definition at line 204 of file clufactor.h.
◆ diag
◆ factorCount
◆ factorTime
◆ hugeValues
◆ initMaxabs
maximum abs number in initail Matrix
Definition at line 200 of file clufactor.h.
◆ lMemMult
factor of minimum Memory * number of nonzeros
Definition at line 205 of file clufactor.h.
◆ maxabs
◆ nzCnt
◆ row
◆ rowMemMult
factor of minimum Memory * number of nonzeros
Definition at line 203 of file clufactor.h.
◆ stat
◆ temp
◆ thedim
◆ work
Working array: must always be left as 0!
Definition at line 214 of file clufactor.h.
|