Class xlifepp::SymSkylineStorage

class SymSkylineStorage : public xlifepp::SkylineStorage

Inheritence diagram for xlifepp::SymSkylineStorage:

Collaboration diagram for xlifepp::SymSkylineStorage:

child class dealing with skyline storage of matrix with symmetry

Public Functions

SymSkylineStorage(const std::vector<number_t>&, string_t)

explicit constructor

SymSkylineStorage(number_t n = 0, string_t id = "SymmSkylineStorage")

default constructor

template<class L>
SymSkylineStorage(number_t, const std::vector<L>&, string_t id = "SymmSkylineStorage")

constructor by the list of col index by rows

inline ~SymSkylineStorage()

destructor constructor by a pair of global numerotation vectors

template<typename M1, typename M2, typename R>
void addMatrixMatrix(const std::vector<M1>&, const std::vector<M2>&, std::vector<R>&) const

templated row dense Matrix + Matrix

Add two matrices.

Parameters:

• m1 – vector values_ of first matrix

• m2 – vector values_ of second matrix

• r – vector values_ of result matrix

inline virtual void addMatrixMatrix(const std::vector<real_t> &m, const std::vector<real_t> &v, std::vector<real_t> &rv) const

specializations of Matrix + Matrix

virtual void addSubMatrixIndices(const std::vector<number_t>&, const std::vector<number_t>&)

add dense submatrix indices to storage

inline virtual void addTwoMatrix(std::vector<real_t> &m1, SymType st1, const std::vector<number_t> &rowPtr2, const std::vector<number_t> &colPtr2, const std::vector<real_t> &m2, SymType st2)

specializations of addition of skyline matrices

template<typename M1, typename M2>
void addTwoMatrixSymSkyline(std::vector<M1>&, SymType, const std::vector<number_t>&, const std::vector<number_t>&, const std::vector<M2>&, SymType)

addition of 2 skyline matrices

Addition two skyline matrices.

Parameters:

• m1 – [inout] vector values_ of the first matrix

• st1 – [in] symmetric type of the first matrix

• rowPtr2 – [in] rowPointer of storage of the second matrix

• colPtr2 – [in] colPointer of storage of the second matrix

• m2 – [in] vector values_ of the second matrix

• st2 – [in] symmetric type of the second matrix

inline virtual void clear()

clear storage vectors

inline virtual SymSkylineStorage *clone() const

create a clone (virtual copy constructor, covariant)

inline virtual const std::vector<number_t> &colPointer() const

colPointer of skyline storage (return rowPointer)

inline virtual void diagonalMatrixVector(const std::vector<real_t> &m, const std::vector<real_t> &v, std::vector<real_t> &rv, SymType s) const

diag Matrix * Vector (Scalar)

template<typename M, typename V, typename X>
void diagonalSolver(const std::vector<M> &m, std::vector<V> &v, std::vector<X> &x) const

Diagonal linear system solver: D x = b.

inline virtual void diagonalSolver(const std::vector<real_t> &m, std::vector<real_t> &v, std::vector<real_t> &x) const

Specializations of diagonal linear solvers D x = v.

virtual std::vector<std::pair<number_t, number_t>> getCol(SymType s, number_t c, number_t r1 = 1, number_t r2 = 0) const

get (row indices, adress) of col c in set [r1,r2]

virtual std::vector<std::pair<number_t, number_t>> getRow(SymType s, number_t r, number_t c1 = 1, number_t c2 = 0) const

get (col indices, adress) of row r in set [c1,c2]

inline virtual void ldlstar(std::vector<complex_t> &m, std::vector<complex_t> &fa) const

specializations of template LDL*

template<typename M>
void ldlstar(std::vector<M> &m, std::vector<M> &fa) const

Matrix factorization with LDL*.

template<typename M>
void ldlstarParallel(std::vector<M> &m, std::vector<M> &fa) const

Matrix factorization with LDL*.

template<typename M>
void ldlt(std::vector<M> &m, std::vector<M> &fa, const SymType sym = _symmetric) const

Matrix factorization with LDLt.

Template L.D.Lt factorization

Factorization of matrix M as matrix F = L D Lt where L is a lower triangular matrix with unit diagonal and is stored as the strict lower triangular part of F and D is a diagonal matrix stored as diagonal of matrix F:

\(\sum_{ C1(i) <= k <= j } L_{ik} D_{kk} L_{jk} = M_{ij} for ( j <= i )\)

where C1(i) is the column index of first non zero entry on row i

inline virtual void ldlt(std::vector<real_t> &m, std::vector<real_t> &fa, const SymType sym = _symmetric) const

specializations of template LDLT

template<typename M>
void ldltParallel(std::vector<M> &m, std::vector<M> &fa, const SymType sym = _symmetric) const

Matrix factorization with LDLt.

inline virtual void loadFromFileCoo(std::istream &ifs, std::vector<complex_t> &mat, SymType sym, bool realAsCmplx)

load a coordinate complex matrix from file

inline virtual void loadFromFileCoo(std::istream &ifs, std::vector<real_t> &mat, SymType sym, bool realAsCmplx)

load a coordinate real matrix from file

inline virtual void loadFromFileDense(std::istream &ifs, std::vector<complex_t> &mat, SymType sym, bool realAsCmplx)

load a dense complex matrix from file

inline virtual void loadFromFileDense(std::istream &ifs, std::vector<real_t> &mat, SymType sym, bool realAsCmplx)

load a dense real matrix from file

inline virtual void lowerD1MatrixVector(const std::vector<real_t> &m, const std::vector<real_t> &v, std::vector<real_t> &rv, SymType s) const

lower Matrix diag 1 (Scalar) * Vector (Scalar)

template<typename M, typename V, typename X>
void lowerD1Solver(const std::vector<M> &m, std::vector<V> &v, std::vector<X> &x) const

Lower triangular with unit diagonal linear system solver: (I+L) x = b.

inline virtual void lowerD1Solver(const std::vector<real_t> &m, std::vector<real_t> &v, std::vector<real_t> &x) const

Specializations of lower triangular part with unit diagonal linear solvers (I + L) x = v */.

inline virtual void lowerMatrixVector(const std::vector<real_t> &m, const std::vector<real_t> &v, std::vector<real_t> &rv, SymType s) const

lower Matrix (Scalar) * Vector (Scalar)

inline virtual number_t lowerPartSize() const

returns number of entries of lower triangular part

template<typename M>
void lu(std::vector<M> &m, std::vector<M> &fa, const SymType sym = _noSymmetry) const

Matrix factorization with LU.

inline virtual void lu(std::vector<real_t> &m, std::vector<real_t> &fa, const SymType sym = _noSymmetry) const

specializations of template LU

template<typename M>
void luParallel(std::vector<M> &m, std::vector<M> &fa, const SymType sym = _noSymmetry) const

Matrix factorization with LU.

template<typename M, typename V, typename R>
void multMatrixVector(const std::vector<M>&, const std::vector<V>&, std::vector<R>&, SymType sym) const

templated sym_skyline Matrix x Vector

template<typename M, typename V, typename R>
void multMatrixVector(const std::vector<M> &m, V *vp, R *rp, SymType sym) const

templated sym_skyline Matrix x Vector (pointer form)

inline virtual void multMatrixVector(const std::vector<Matrix<real_t>> &m, const std::vector<Vector<real_t>> &v, std::vector<Vector<real_t>> &rv, SymType sym) const

Matrix (Matrix) * Vector (Vector)

inline virtual void multMatrixVector(const std::vector<real_t> &m, const std::vector<real_t> &v, std::vector<real_t> &rv, SymType sym) const

Matrix (Scalar) * Vector (Scalar)

inline virtual void multMatrixVector(const std::vector<real_t> &m, real_t *vp, real_t *rp, SymType sym) const

Matrix * Vector (pointer form)

template<typename M, typename V, typename R>
void multVectorMatrix(const std::vector<M>&, const std::vector<V>&, std::vector<R>&, SymType sym) const

templated Vector x sym_skyline Matrix

template<typename M, typename V, typename R>
void multVectorMatrix(const std::vector<M> &m, V *vp, R *rp, SymType sym) const

templated Vector x sym_skyline Matrix (pointer form)

inline virtual void multVectorMatrix(const std::vector<Matrix<real_t>> &m, const std::vector<Vector<real_t>> &v, std::vector<Vector<real_t>> &rv, SymType sym) const

Matrix (Matrix) * Vector (Vector)

inline virtual void multVectorMatrix(const std::vector<real_t> &m, const std::vector<real_t> &v, std::vector<real_t> &rv, SymType sym) const

Vector (Scalar) * Matrix (Scalar)

inline virtual void multVectorMatrix(const std::vector<real_t> &m, real_t *vp, real_t *rp, SymType sym) const

Vector * Matrix (pointer form)

virtual number_t pos(number_t i, number_t j, SymType s = _noSymmetry) const

returns adress of entry (i,j)

virtual void positions(const std::vector<number_t>&, const std::vector<number_t>&, std::vector<number_t>&, bool errorOn = true, SymType = _noSymmetry) const

access to submatrix positions

inline virtual void print(PrintStream &os) const

visualize storage on ostream

virtual void print(std::ostream&) const

print storage pointers

void printCooMatrix(std::ostream&, const std::vector<complex_t>&, SymType s = _noSymmetry) const

output matrix of real scalars in coordinate form

void printCooMatrix(std::ostream&, const std::vector<Matrix<complex_t>>&, SymType s = _noSymmetry) const

output matrix of complex scalars in coordinate form

void printCooMatrix(std::ostream&, const std::vector<Matrix<real_t>>&, SymType s = _noSymmetry) const

output matrix of real scalars in coordinate form

void printCooMatrix(std::ostream&, const std::vector<real_t>&, SymType s = _noSymmetry) const

output matrix of real scalars in coordinate form

virtual void printEntries(std::ostream&, const std::vector<complex_t>&, number_t vb, const SymType sym) const

print complex scalar matrix

virtual void printEntries(std::ostream&, const std::vector<Matrix<complex_t>>&, number_t vb, const SymType sym) const

print matrix of complex matrices

virtual void printEntries(std::ostream&, const std::vector<Matrix<real_t>>&, number_t vb, const SymType sym) const

print matrix of real matrices

virtual void printEntries(std::ostream&, const std::vector<real_t>&, number_t vb, const SymType sym) const

print real scalar matrix

void printEntries(std::ostream&, const std::vector<Vector<complex_t>>&, number_t vb, const SymType sym) const

print matrix of complex vectors (not available)

void printEntries(std::ostream&, const std::vector<Vector<real_t>>&, number_t vb, const SymType sym) const

print matrix of real vectors (not available)

inline virtual const std::vector<number_t> &rowPointer() const

returns rowPointer_ (const)

virtual bool sameStorage(const MatrixStorage&) const

check if two storages have the same structures

inline virtual void setDiagValue(std::vector<complex_t> &m, const complex_t k)

Set value of Diagonal (complex)

inline virtual void setDiagValue(std::vector<real_t> &m, const real_t k)

Set value of Diagonal (real)

template<typename T>
inline void setDiagValueSymSkyline(std::vector<T> &v, const T m)

Set the Diagonal with a specific value.

inline virtual number_t size() const

number of non zero elements stored

virtual SymSkylineStorage *toScalar(dimen_t, dimen_t)

create a new scalar SymSkyline storage from current SymSkyline storage and submatrix sizes

template<typename M, typename OrdinalType>
void toUmfPack(const std::vector<M> &values, std::vector<OrdinalType> &colPointer, std::vector<OrdinalType> &rowIndex, std::vector<M> &mat, const SymType sym = _noSymmetry) const

conversion to umfpack format

template<typename M1, typename Idx>
void toUmfPack(const std::vector<M1> &m1, std::vector<Idx> &colPtUmf, std::vector<Idx> &rowIdxUmf, std::vector<M1> &resultUmf, const SymType sym) const

Extract and convert matrix storage to UMFPack format (Matlab sparse matrix)

Parameters:

• m1 – vector values_ current matrix

• colPtUmf – vector column Pointer of UMFPack format

• rowIdxUmf – vector row Index of UMFPack format

• resultUmf – vector values of UMFPack format

• sym – type of symmetry

inline virtual void toUmfPack(const std::vector<real_t> &values, std::vector<int_t> &colPointer, std::vector<int_t> &rowIndex, std::vector<real_t> &mat, const SymType sym) const

specializations of umfpack conversions

inline virtual void upperD1MatrixVector(const std::vector<real_t> &m, const std::vector<real_t> &v, std::vector<real_t> &rv, SymType s) const

upper Matrix diag 1 (Scalar) * Vector (Scalar)

template<typename M, typename V, typename X>
void upperD1Solver(const std::vector<M> &m, std::vector<V> &v, std::vector<X> &x, const SymType sym) const

Upper triangular with unit diagonal linear system solver: (I+U) x = b.

inline virtual void upperD1Solver(const std::vector<real_t> &m, std::vector<real_t> &v, std::vector<real_t> &x, const SymType sym = _noSymmetry) const

Specializations of upper triangular part with unit diagonal linear solvers (I + U) x = v.

inline virtual void upperMatrixVector(const std::vector<real_t> &m, const std::vector<real_t> &v, std::vector<real_t> &rv, SymType s) const

upper Matrix (Scalar) * Vector (Scalar)

inline virtual number_t upperPartSize() const

returns number of entries of upper triangular part

template<typename M, typename V, typename X>
void upperSolver(const std::vector<M> &m, std::vector<V> &v, std::vector<X> &x, const SymType sym) const

upper triangular linear system solver: (D+U) x = b

inline virtual void upperSolver(const std::vector<real_t> &m, std::vector<real_t> &v, std::vector<real_t> &x, const SymType sym = _noSymmetry) const

specializations of upper triangular part linear solvers (D + U) x = v