nimble::CRSMatrixContainer Class Reference

#include <nimble_linear_solver.h>

Public Member Functions
	CRSMatrixContainer ()
	~CRSMatrixContainer ()=default
void	AllocateNonzeros (std::vector< int > const &i_index, std::vector< int > const &j_index)
void	AllocateDiagonalMatrix (int num_rows)
void	SetAllValues (double value)
void	SetRowValues (int row, double value)
void	SetColumnValues (int col, double value)
int	NumRows () const
unsigned int	NumNonzeros () const
void	MatVec (const double *vec, double *result) const
void	DiagonalMatrixMatVec (const double *vec, double *result) const
double	operator() (int i_index, int j_index) const
double &	operator() (int i_index, int j_index)

Friends
void	PopulateDiagonalPreconditioner (const CRSMatrixContainer &A, CRSMatrixContainer &M)
	Generate a diagonal preconditioner from a sparse matrix.

Constructor & Destructor Documentation

CRSMatrixContainer()

nimble::CRSMatrixContainer::CRSMatrixContainer ( )

inline

: num_rows_(0) {}

~CRSMatrixContainer()

nimble::CRSMatrixContainer::~CRSMatrixContainer ( )

default

Member Function Documentation

AllocateDiagonalMatrix()

void nimble::CRSMatrixContainer::AllocateDiagonalMatrix ( int num_rows )

inline

  {
    if (num_rows_ == num_rows) { return; }
    num_rows_ = num_rows;
    data_.resize(num_rows_);
    i_index_.resize(num_rows_);
    j_index_.resize(num_rows_);
    row_first_index_.resize(num_rows_);
    for (int i = 0; i < num_rows_; i++) {
      data_[i]            = 0.0;
      i_index_[i]         = i;
      j_index_[i]         = i;
      row_first_index_[i] = i;
    }
  }

AllocateNonzeros()

void nimble::CRSMatrixContainer::AllocateNonzeros	(	std::vector< int > const &	i_index,
		std::vector< int > const &	j_index )

{
  i_index_ = i_index;
  j_index_ = j_index;
  data_.resize(i_index.size(), 0.0);
  int max_row = 0;
  for (auto const& i : i_index) {
    if (i > max_row) { max_row = i; }
  }
  num_rows_ = max_row + 1;
  row_first_index_.resize(num_rows_ + 1);
  int current_row = -1;
  for (int i = 0; i < i_index_.size(); i++) {
    int row = i_index_[i];
    if (row > current_row) {
      row_first_index_[row] = i;
      current_row           = row;
    }
  }
  row_first_index_[num_rows_] = i_index_.size();
}

DiagonalMatrixMatVec()

void nimble::CRSMatrixContainer::DiagonalMatrixMatVec	(	const double *	vec,
		double *	result ) const

{
  // the matrix must be diagonal
  if (num_rows_ != data_.size()) {
    NIMBLE_ABORT(
        "**** Error in CRSMatrixContainer::DiagonalMatrixMatVec(), matrix is "
        "not diagonal.\n");
  }
 
  for (unsigned int i = 0; i < num_rows_; i++) { result[i] = data_[i] * vec[i]; }
}

MatVec()

void nimble::CRSMatrixContainer::MatVec	(	const double *	vec,
		double *	result ) const

{
  for (unsigned int i_row = 0; i_row < num_rows_; i_row++) { result[i_row] = 0.0; }
  for (unsigned int i = 0; i < data_.size(); i++) { result[i_index_[i]] += data_[i] * vec[j_index_[i]]; }
}

NumNonzeros()

unsigned int nimble::CRSMatrixContainer::NumNonzeros ( ) const

inline

  {
    return data_.size();
  }

NumRows()

int nimble::CRSMatrixContainer::NumRows ( ) const

inline

  {
    return num_rows_;
  }

operator()() [1/2]

double & nimble::CRSMatrixContainer::operator() ( int i_index, int j_index )

inline

  {
    return data_[FindIndex(i_index, j_index)];
  }

operator()() [2/2]

double nimble::CRSMatrixContainer::operator() ( int i_index, int j_index ) const

inline

  {
    return data_[FindIndex(i_index, j_index)];
  }

SetAllValues()

void nimble::CRSMatrixContainer::SetAllValues ( double value )

inline

  {
    for (double& d_data : data_) d_data = value;
  }

SetColumnValues()

void nimble::CRSMatrixContainer::SetColumnValues	(	int	col,
		double	value )

{
  for (int i = 0; i < j_index_.size(); i++) {
    if (j_index_[i] == col) { data_[i] = value; }
  }
}

SetRowValues()

void nimble::CRSMatrixContainer::SetRowValues	(	int	row,
		double	value )

{
  for (int i = row_first_index_[row]; i < row_first_index_[row + 1]; i++) { data_[i] = value; }
}

Friends And Related Symbol Documentation

PopulateDiagonalPreconditioner

void PopulateDiagonalPreconditioner ( const CRSMatrixContainer & A, CRSMatrixContainer & M )

friend

Generate a diagonal preconditioner from a sparse matrix.

Parameters

A	Input sparse matrix
M	Diagonal preconditioner (mathematically M = (diag(A))^{-1})

{
  // the preconditioner must be a diagonal matrix
  if (M.num_rows_ != M.data_.size()) {
    throw std::invalid_argument(
        "**** Error in PopulateDiagonalPreconditioner(), preconditioner must "
        "be a diagonal matrix.\n");
  }
 
  int m_index(0);
  for (int i = 0; i < A.data_.size(); i++) {
    if (A.i_index_[i] == A.j_index_[i]) { M.data_[m_index++] = 1.0 / A.data_[i]; }
  }
}

---

The documentation for this class was generated from the following files:

• src/nimble_linear_solver.h
• src/nimble_linear_solver.cc