|
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) |
|
|
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()
template<class R >
void eliminateColSingletons |
( |
| ) |
|
|
private |
◆ eliminateNucleus()
template<class R >
void eliminateNucleus |
( |
const R | eps, |
|
|
const R | threshold ) |
|
private |
◆ eliminatePivot()
template<class R >
void eliminatePivot |
( |
int | prow, |
|
|
int | pos, |
|
|
R | eps ) |
|
private |
◆ eliminateRowSingletons()
template<class R >
void eliminateRowSingletons |
( |
| ) |
|
|
private |
◆ factor()
template<class R >
void factor |
( |
const SVectorBase< R > ** | vec, |
|
|
R | threshold, |
|
|
R | eps ) |
|
protected |
- Parameters
-
vec | Array of column VectorBase<R> pointers |
threshold | pivoting threshold |
eps | epsilon for zero detection |
◆ forestMinColMem()
template<class R >
void forestMinColMem |
( |
int | size | ) |
|
|
private |
◆ forestPackColumns()
template<class R >
void forestPackColumns |
( |
| ) |
|
|
private |
◆ forestReMaxCol()
template<class R >
void forestReMaxCol |
( |
int | col, |
|
|
int | len ) |
|
private |
◆ forestUpdate()
template<class R >
void forestUpdate |
( |
int | col, |
|
|
R * | work, |
|
|
int | num, |
|
|
int * | nonz ) |
|
protected |
◆ freeFactorRings()
◆ initFactorMatrix()
template<class R >
void initFactorMatrix |
( |
const SVectorBase< R > ** | vec, |
|
|
const R | eps ) |
|
private |
◆ initFactorRings()
◆ initPerm()
◆ isConsistent()
template<class R >
bool isConsistent |
( |
| ) |
const |
|
protected |
◆ makeLvec()
template<class R >
int makeLvec |
( |
int | p_len, |
|
|
int | p_row ) |
|
private |
◆ minColMem()
template<class R >
void minColMem |
( |
int | size | ) |
|
|
private |
◆ minLMem()
◆ minRowMem()
template<class R >
void minRowMem |
( |
int | size | ) |
|
|
private |
◆ packColumns()
◆ packRows()
◆ remaxCol()
template<class R >
void remaxCol |
( |
int | p_col, |
|
|
int | len ) |
|
private |
◆ remaxRow()
template<class R >
void remaxRow |
( |
int | p_row, |
|
|
int | len ) |
|
private |
◆ rowSingletons()
◆ selectPivots()
template<class R >
void selectPivots |
( |
R | threshold | ) |
|
|
private |
◆ setPivot()
template<class R >
void setPivot |
( |
const int | p_stage, |
|
|
const int | p_col, |
|
|
const int | p_row, |
|
|
const R | val ) |
|
private |
◆ setTolerances()
template<class R >
void setTolerances |
( |
std::shared_ptr< Tolerances > | tolerances | ) |
|
◆ setupColVals()
◆ setupRowVals()
◆ solveLeft()
template<class R >
void solveLeft |
( |
R * | vec, |
|
|
R * | rhs ) |
|
protected |
◆ solveLeft2()
template<class R >
int solveLeft2 |
( |
R * | vec1, |
|
|
int * | nonz, |
|
|
R * | vec2, |
|
|
R | eps, |
|
|
R * | rhs1, |
|
|
R * | rhs2 ) |
|
protected |
◆ solveLeftEps()
template<class R >
int solveLeftEps |
( |
R * | vec, |
|
|
R * | rhs, |
|
|
int * | nonz, |
|
|
R | eps ) |
|
protected |
◆ solveLleft() [1/2]
template<class R >
void solveLleft |
( |
R * | vec | ) |
const |
|
private |
◆ solveLleft() [2/2]
template<class R >
int solveLleft |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | nonz, |
|
|
int | rn ) |
|
private |
◆ solveLleft2()
template<class R >
void solveLleft2 |
( |
R * | vec1, |
|
|
int * | , |
|
|
R * | vec2, |
|
|
R | ) |
|
private |
◆ solveLleft2forest()
template<class R >
int solveLleft2forest |
( |
R * | vec1, |
|
|
int * | , |
|
|
R * | vec2, |
|
|
R | ) |
|
private |
◆ solveLleftEps()
template<class R >
int solveLleftEps |
( |
R * | vec, |
|
|
int * | nonz, |
|
|
R | eps ) |
|
private |
◆ solveLleftForest() [1/2]
template<class R >
int solveLleftForest |
( |
R * | vec, |
|
|
int * | , |
|
|
R | ) |
|
private |
◆ solveLleftForest() [2/2]
template<class R >
int solveLleftForest |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | nonz, |
|
|
int | n ) |
|
private |
◆ solveLleftForestNoNZ()
template<class R >
void solveLleftForestNoNZ |
( |
R * | vec | ) |
|
|
private |
◆ solveLleftNoNZ()
template<class R >
void solveLleftNoNZ |
( |
R * | vec | ) |
|
|
private |
◆ solveLright()
template<class R >
void solveLright |
( |
R * | vec | ) |
|
|
protected |
◆ solveLright2()
template<class R >
void solveLright2 |
( |
R * | vec1, |
|
|
R * | vec2 ) |
|
private |
◆ solveRight()
template<class R >
void solveRight |
( |
R * | vec, |
|
|
R * | rhs ) |
|
protected |
◆ solveRight2()
template<class R >
void solveRight2 |
( |
R * | vec1, |
|
|
R * | vec2, |
|
|
R * | rhs1, |
|
|
R * | rhs2 ) |
|
protected |
◆ solveRight2update()
template<class R >
int solveRight2update |
( |
R * | vec1, |
|
|
R * | vec2, |
|
|
R * | rhs1, |
|
|
R * | rhs2, |
|
|
int * | nonz, |
|
|
R | eps, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
◆ solveRight4update()
template<class R >
int solveRight4update |
( |
R * | vec, |
|
|
int * | nonz, |
|
|
R | eps, |
|
|
R * | rhs, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
◆ solveUleft() [1/2]
template<class R >
void solveUleft |
( |
R * | work, |
|
|
R * | vec ) |
|
private |
◆ solveUleft() [2/2]
template<class R >
int solveUleft |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | vecidx, |
|
|
R * | rhs, |
|
|
int * | rhsidx, |
|
|
int | rhsn ) |
|
private |
◆ solveUleft2()
template<class R >
void solveUleft2 |
( |
R * | work1, |
|
|
R * | vec1, |
|
|
R * | work2, |
|
|
R * | vec2 ) |
|
private |
◆ solveUleftNoNZ()
template<class R >
void solveUleftNoNZ |
( |
R | eps, |
|
|
R * | vec, |
|
|
R * | rhs, |
|
|
int * | rhsidx, |
|
|
int | rhsn ) |
|
private |
◆ solveUpdateLeft() [1/2]
template<class R >
void solveUpdateLeft |
( |
R * | vec | ) |
|
|
private |
◆ solveUpdateLeft() [2/2]
template<class R >
int solveUpdateLeft |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | nonz, |
|
|
int | n ) |
|
private |
◆ solveUpdateLeft2()
template<class R >
void solveUpdateLeft2 |
( |
R * | vec1, |
|
|
R * | vec2 ) |
|
private |
◆ solveUpdateRight()
template<class R >
void solveUpdateRight |
( |
R * | vec | ) |
|
|
private |
◆ solveUpdateRight2()
template<class R >
void solveUpdateRight2 |
( |
R * | vec1, |
|
|
R * | vec2 ) |
|
private |
◆ solveUright()
template<class R >
void solveUright |
( |
R * | wrk, |
|
|
R * | vec ) const |
|
private |
◆ solveUright2()
template<class R >
void solveUright2 |
( |
R * | work1, |
|
|
R * | vec1, |
|
|
R * | work2, |
|
|
R * | vec2 ) |
|
private |
◆ solveUright2eps()
template<class R >
int solveUright2eps |
( |
R * | work1, |
|
|
R * | vec1, |
|
|
R * | work2, |
|
|
R * | vec2, |
|
|
int * | nonz, |
|
|
R | eps ) |
|
private |
◆ solveUrightEps()
template<class R >
int solveUrightEps |
( |
R * | vec, |
|
|
int * | nonz, |
|
|
R | eps, |
|
|
R * | rhs ) |
|
private |
◆ tolerances()
template<class R >
const std::shared_ptr< Tolerances > tolerances |
( |
| ) |
const |
◆ update()
template<class R >
void update |
( |
int | p_col, |
|
|
R * | p_work, |
|
|
const int * | p_idx, |
|
|
int | num ) |
|
protected |
◆ updateNoClear()
template<class R >
void updateNoClear |
( |
int | p_col, |
|
|
const R * | p_work, |
|
|
const int * | p_idx, |
|
|
int | num ) |
|
protected |
◆ updateRow()
template<class R >
int updateRow |
( |
int | r, |
|
|
int | lv, |
|
|
int | prow, |
|
|
int | pcol, |
|
|
R | pval, |
|
|
R | eps ) |
|
private |
◆ updateSolutionVectorLright()
template<class R >
void updateSolutionVectorLright |
( |
R | change, |
|
|
int | j, |
|
|
R & | vec, |
|
|
int * | idx, |
|
|
int & | nnz ) |
|
private |
◆ vSolveLeft()
template<class R >
int vSolveLeft |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn ) |
|
protected |
◆ vSolveLeft2()
template<class R >
int vSolveLeft2 |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R * | vec2, |
|
|
R * | rhs2, |
|
|
int * | ridx2, |
|
|
int | rn2 ) |
|
protected |
◆ vSolveLeft2sparse()
template<class R >
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()
template<class R >
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()
template<class R >
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()
template<class R >
void vSolveLeftNoNZ |
( |
R | eps, |
|
|
R * | vec, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn ) |
|
protected |
◆ vSolveLright()
template<class R >
void vSolveLright |
( |
R * | vec, |
|
|
int * | ridx, |
|
|
int & | rn, |
|
|
R | eps ) |
|
private |
◆ vSolveLright2()
template<class R >
void vSolveLright2 |
( |
R * | vec, |
|
|
int * | ridx, |
|
|
int & | rn, |
|
|
R | eps, |
|
|
R * | vec2, |
|
|
int * | ridx2, |
|
|
int & | rn2, |
|
|
R | eps2 ) |
|
private |
◆ vSolveLright3()
template<class R >
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()
template<class R >
int vSolveRight4update |
( |
R | eps, |
|
|
R * | vec, |
|
|
int * | idx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R * | forest, |
|
|
int * | forestNum, |
|
|
int * | forestIdx ) |
|
protected |
◆ vSolveRight4update2()
template<class R >
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()
template<class R >
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()
template<class R >
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()
template<class R >
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()
template<class R >
void vSolveRightNoNZ |
( |
R * | vec, |
|
|
R | eps, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn ) |
|
protected |
◆ vSolveUpdateRight()
template<class R >
int vSolveUpdateRight |
( |
R * | vec, |
|
|
int * | ridx, |
|
|
int | n, |
|
|
R | eps ) |
|
private |
◆ vSolveUpdateRightNoNZ()
template<class R >
void vSolveUpdateRightNoNZ |
( |
R * | vec, |
|
|
R | ) |
|
private |
◆ vSolveUright()
template<class R >
int vSolveUright |
( |
R * | vec, |
|
|
int * | vidx, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R | eps ) |
|
private |
◆ vSolveUright2()
template<class R >
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()
template<class R >
void vSolveUrightNoNZ |
( |
R * | vec, |
|
|
R * | rhs, |
|
|
int * | ridx, |
|
|
int | rn, |
|
|
R | eps ) |
|
private |
◆ _tolerances
◆ col
column permutation matrices
Definition at line 219 of file clufactor.h.
◆ colMemMult
factor of minimum Memory * number of nonzeros
Definition at line 215 of file clufactor.h.
◆ diag
◆ factorCount
◆ factorTime
◆ hugeValues
◆ initMaxabs
maximum abs number in initail Matrix
Definition at line 211 of file clufactor.h.
◆ lMemMult
factor of minimum Memory * number of nonzeros
Definition at line 216 of file clufactor.h.
◆ maxabs
◆ nzCnt
◆ row
◆ rowMemMult
factor of minimum Memory * number of nonzeros
Definition at line 214 of file clufactor.h.
◆ stat
◆ temp
◆ thedim
◆ work
Working array: must always be left as 0!
Definition at line 225 of file clufactor.h.
|