STLMatrix.h¶

Note

The documentation on this page was automatically extracted from the DOLFIN C++ code and may need to be edited or expanded.

class STLMatrix¶

Parent class(es)

GenericMatrix

Simple STL-based implementation of the GenericMatrix interface. The sparse matrix is stored as a pair of std::vector of std::vector, one for the columns and one for the values.

Historically, this class has undergone a number of different incarnations, based on various combinations of std::vector, std::set and std::map. The current implementation has proven to be the fastest.

STLMatrix(std::size_t primary_dim = 0)¶: Create empty matrix

void init(const TensorLayout &tensor_layout)¶: — Implementation of the GenericTensor interface — Initialize zero tensor using sparsity pattern

bool empty() const¶: Return true if empty

std::size_t size(std::size_t dim) const¶: Return size of given dimension

std::pair<std::size_t, std::size_t> local_range(std::size_t dim) const¶: Return local ownership range

void zero()¶: Set all entries to zero and keep any sparse structure

void apply(std::string mode)¶: Finalize assembly of tensor

MPI_Comm mpi_comm() const¶: Return MPI communicator

std::string str(bool verbose) const¶: Return informal string representation (pretty-print)

std::shared_ptr<GenericMatrix> copy() const¶: Return copy of matrix

void init_vector(GenericVector &z, std::size_t dim) const¶

Initialize vector z to be compatible with the matrix-vector product y = Ax. In the parallel case, both size and layout are important.

Arguments

dim (std::size_t): The dimension (axis): dim = 0 –> z = y, dim = 1 –> z = x

void get(double *block, std::size_t m, const dolfin::la_index *rows, std::size_t n, const dolfin::la_index *cols) const¶: Get block of values

void set(const double *block, std::size_t m, const dolfin::la_index *rows, std::size_t n, const dolfin::la_index *cols)¶: Set block of values using global indices

void set_local(const double *block, std::size_t m, const dolfin::la_index *rows, std::size_t n, const dolfin::la_index *cols)¶: Set block of values using local indices

void add(const double *block, std::size_t m, const dolfin::la_index *rows, std::size_t n, const dolfin::la_index *cols)¶: Add block of values using global indices

void add_local(const double *block, std::size_t m, const dolfin::la_index *rows, std::size_t n, const dolfin::la_index *cols)¶: Add block of values using local indices

void axpy(double a, const GenericMatrix &A, bool same_nonzero_pattern)¶: Add multiple of given matrix (AXPY operation)

double norm(std::string norm_type) const¶: Return norm of matrix

void getrow(std::size_t row, std::vector<std::size_t> &columns, std::vector<double> &values) const¶: Get non-zero values of given row

void setrow(std::size_t row, const std::vector<std::size_t> &columns, const std::vector<double> &values)¶: Set values for given row

void zero(std::size_t m, const dolfin::la_index *rows)¶: Set given rows (global row indices) to zero

void zero_local(std::size_t m, const dolfin::la_index *rows)¶: Set given rows (local row indices) to zero

void ident(std::size_t m, const dolfin::la_index *rows)¶: Set given rows to identity matrix

void ident_local(std::size_t m, const dolfin::la_index *rows)¶: Set given rows to identity matrix

void get_diagonal(GenericVector &x) const¶: Get diagonal of a matrix

void set_diagonal(const GenericVector &x)¶: Set diagonal of a matrix

const STLMatrix &operator*=(double a)¶: Multiply matrix by given number

const STLMatrix &operator/=(double a)¶: Divide matrix by given number

const GenericMatrix &operator=(const GenericMatrix &A)¶: Assignment operator

GenericLinearAlgebraFactory &factory() const¶: — Specialized matrix functions — Return linear algebra backend factory

std::size_t block_size() const¶: — STLMatrix interface — Return matrix block size

void clear()¶: Clear matrix. Destroys data and sparse layout

void csr(std::vector<double> &vals, std::vector<T> &cols, std::vector<T> &row_ptr, std::vector<T> &local_to_global_row, bool block, bool symmetric) const¶: Return matrix in CSR format

void csc(std::vector<double> &vals, std::vector<T> &rows, std::vector<T> &col_ptr, std::vector<T> &local_to_global_col, bool block, bool symmetric) const¶: Return matrix in CSC format

std::size_t nnz() const¶: Return number of global non-zero entries

std::size_t local_nnz() const¶: Return number of local non-zero entries

void compressed_storage(std::vector<double> &vals, std::vector<T> &rows, std::vector<T> &col_ptr, std::vector<T> &local_to_global_col, bool block, bool symmetric) const¶: Return matrix in compressed format