oomph::CRMatrix< T > Class Template Reference

#include <matrices.h>

Inheritance diagram for oomph::CRMatrix< T >:

Public Member Functions
	CRMatrix ()
	Default constructor. More...
	CRMatrix (const Vector< T > &value, const Vector< int > &column_index_, const Vector< int > &row_start_, const unsigned long &n, const unsigned long &m)
	CRMatrix (const CRMatrix &source_matrix)
	Copy constructor. More...
void	operator= (const CRMatrix &)=delete
	Broken assignment operator. More...
virtual	~CRMatrix ()
	Destructor, delete any allocated memory. More...
T	get_entry (const unsigned long &i, const unsigned long &j) const
T &	entry (const unsigned long &i, const unsigned long &j)
	The read-write access function is deliberately broken. More...
int *	row_start ()
	Access to C-style row_start array. More...
const int *	row_start () const
	Access to C-style row_start array (const version) More...
int *	column_index ()
	Access to C-style column index array. More...
const int *	column_index () const
	Access to C-style column index array (const version) More...
void	output_bottom_right_zero_helper (std::ostream &outfile) const
void	sparse_indexed_output_helper (std::ostream &outfile) const
void	clean_up_memory ()
	Wipe matrix data and set all values to 0. More...
void	build (const Vector< T > &value, const Vector< int > &column_index, const Vector< int > &row_start, const unsigned long &n, const unsigned long &m)
void	build_without_copy (T *value, int *column_index, int *row_start, const unsigned long &nnz, const unsigned long &n, const unsigned long &m)
Public Member Functions inherited from oomph::SparseMatrix< T, CRMatrix< T > >
	SparseMatrix ()
	Default constructor. More...
	SparseMatrix (const SparseMatrix &source_matrix)
	Copy constructor. More...
void	operator= (const SparseMatrix &)=delete
	Broken assignment operator. More...
virtual	~SparseMatrix ()
	Destructor, delete the memory associated with the values. More...
T *	value ()
	Access to C-style value array. More...
const T *	value () const
	Access to C-style value array (const version) More...
unsigned long	nrow () const
	Return the number of rows of the matrix. More...
unsigned long	ncol () const
	Return the number of columns of the matrix. More...
unsigned long	nnz () const
	Return the number of nonzero entries. More...
Public Member Functions inherited from oomph::Matrix< T, MATRIX_TYPE >
	Matrix ()
	(Empty) constructor More...
	Matrix (const Matrix &matrix)=delete
	Broken copy constructor. More...
void	operator= (const Matrix &)=delete
	Broken assignment operator. More...
virtual	~Matrix ()
	Virtual (empty) destructor. More...
T	operator() (const unsigned long &i, const unsigned long &j) const
T &	operator() (const unsigned long &i, const unsigned long &j)
virtual void	output (std::ostream &outfile) const
void	sparse_indexed_output (std::ostream &outfile, const unsigned &precision=0, const bool &output_bottom_right_zero=false) const
void	sparse_indexed_output (std::string filename, const unsigned &precision=0, const bool &output_bottom_right_zero=false) const

Protected Attributes
int *	Column_index
	Column index. More...
int *	Row_start
	Start index for row. More...
Protected Attributes inherited from oomph::SparseMatrix< T, CRMatrix< T > >
T *	Value
	Internal representation of the matrix values, a pointer. More...
unsigned long	N
	Number of rows. More...
unsigned long	M
	Number of columns. More...
unsigned long	Nnz
	Number of non-zero values (i.e. size of Value array) More...

Additional Inherited Members
Protected Member Functions inherited from oomph::Matrix< T, MATRIX_TYPE >
void	range_check (const unsigned long &i, const unsigned long &j) const
Static Protected Attributes inherited from oomph::SparseMatrix< T, CRMatrix< T > >
static T	Zero
	Dummy zero. More...

Detailed Description

template<class T>
class oomph::CRMatrix< T >

A class for compressed row matrices, a sparse storage format Once again the recursive template trick is used to inform that base class that is should use the access functions provided in the CRMatrix class.

Constructor & Destructor Documentation

CRMatrix() [1/3]

template<class T >

oomph::CRMatrix< T >::CRMatrix ( )

inline

Default constructor.

               : SparseMatrix<T, CRMatrix<T>>()
    {
      Column_index = 0;
      Row_start = 0;
    }

References oomph::CRMatrix< T >::Column_index, and oomph::CRMatrix< T >::Row_start.

CRMatrix() [2/3]

template<class T >

oomph::CRMatrix< T >::CRMatrix ( const Vector< T > &  value, const Vector< int > &  column_index_, const Vector< int > &  row_start_, const unsigned long &  n, const unsigned long &  m  )

inline

Constructor: Pass vector of values, vector of column indices, vector of row starts and number of rows and columns Number of nonzero entries is read off from value, so make sure the vector has been shrunk to its correct length.

      : SparseMatrix<T, CRMatrix<T>>()
    {
      Column_index = 0;
      Row_start = 0;
      build(value, column_index_, row_start_, n, m);
    }

References oomph::CRMatrix< T >::build(), oomph::CRMatrix< T >::Column_index, m, n, oomph::CRMatrix< T >::Row_start, and oomph::SparseMatrix< T, CRMatrix< T > >::value().

CRMatrix() [3/3]

template<class T >

oomph::CRMatrix< T >::CRMatrix ( const CRMatrix< T > &  source_matrix )

inline

Copy constructor.

      : SparseMatrix<T, CRMatrix<T>>(source_matrix)
    {
      // NNz, N and M are set the the copy constructor of the SparseMatrix
      // called above
      // Column indices stored in C-style array
      Column_index = new int[this->Nnz];
 
      // Assign:
      for (unsigned long i = 0; i < this->Nnz; i++)
      {
        Column_index[i] = source_matrix.column_index()[i];
      }
 
      // Row start:
      Row_start = new int[this->N + 1];
 
      // Assign:
      for (unsigned long i = 0; i <= this->N; i++)
      {
        Row_start[i] = source_matrix.row_start()[i];
      }
    }

References oomph::CRMatrix< T >::column_index(), oomph::CRMatrix< T >::Column_index, i, oomph::SparseMatrix< T, CRMatrix< T > >::N, oomph::SparseMatrix< T, CRMatrix< T > >::Nnz, oomph::CRMatrix< T >::row_start(), and oomph::CRMatrix< T >::Row_start.

~CRMatrix()

template<class T >

virtual oomph::CRMatrix< T >::~CRMatrix ( )

inlinevirtual

Destructor, delete any allocated memory.

    {
      delete[] Column_index;
      Column_index = 0;
      delete[] Row_start;
      Row_start = 0;
    }

References oomph::CRMatrix< T >::Column_index, and oomph::CRMatrix< T >::Row_start.

Member Function Documentation

build()

template<class T >

void oomph::CRMatrix< T >::build	(	const Vector< T > &	value,
		const Vector< int > &	column_index_,
		const Vector< int > &	row_start_,
		const unsigned long &	n,
		const unsigned long &	m
	)

Build matrix from compressed representation. Number of nonzero entries is read off from value, so make sure the vector has been shrunk to its correct length. This matrix forms the storage for CRDoubleMatrices which are distributable. The argument n should be the number of local rows. The argument m is the number of columns

Build matrix from compressed representation. Number of nonzero entries is read off from value, so make sure the vector has been shrunk to its correct length. The optional final parameter specifies the number of columns. If it is not specified the matrix is assumed to be quadratic.

  {
#ifdef PARANOID
    if (value.size() != column_index_.size())
    {
      std::ostringstream error_message;
      error_message << "Must have the same number of values and column indices,"
                    << "we have " << value.size() << " values and "
                    << column_index_.size() << " column inidicies."
                    << std::endl;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
    // Number of nonzero entries
    this->Nnz = value.size();
 
    // Number of rows
    this->N = n;
 
    // Number of columns
    this->M = m;
 
    // We need to delete any previously allocated  storage
    if (this->Value != 0)
    {
      delete[] this->Value;
    }
    if (this->Column_index != 0)
    {
      delete[] this->Column_index;
    }
    if (this->Row_start != 0)
    {
      delete[] this->Row_start;
    }
 
    // Values stored in C-style array
    this->Value = new T[this->Nnz];
 
    // Column indices stored in C-style array
    this->Column_index = new int[this->Nnz];
 
    // Assign:
    for (unsigned long i = 0; i < this->Nnz; i++)
    {
      this->Value[i] = value[i];
      this->Column_index[i] = column_index_[i];
    }
 
    // Row start:
    // Find the size and allocate
    unsigned long n_row_start = row_start_.size();
    this->Row_start = new int[n_row_start];
 
    // Assign:
    for (unsigned long i = 0; i < n_row_start; i++)
    {
      this->Row_start[i] = row_start_[i];
    }
  }

References i, m, n, N, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Eigen::value.

Referenced by oomph::CRDoubleMatrix::build(), oomph::CRDoubleMatrix::CRDoubleMatrix(), and oomph::CRMatrix< T >::CRMatrix().

build_without_copy()

template<class T >

void oomph::CRMatrix< T >::build_without_copy	(	T *	value,
		int *	column_index_,
		int *	row_start_,
		const unsigned long &	nnz,
		const unsigned long &	n,
		const unsigned long &	m
	)

Function to build matrix from pointers to arrays which hold the row starts, column indices and non-zero values. The final two arguments are the number of rows and columns. Note that, as the name suggests, this function does not make a copy of the data pointed to by the first three arguments!

Function to build a CRMatrix from pointers to arrays which hold the row starts, column indices and non-zero values Note that, as the name suggests, this function does not make a copy of the data pointed to by the first three arguments!

  {
    // Number of nonzero entries
    this->Nnz = nnz;
 
    // Number of rows
    this->N = n;
 
    // Number of columns
    this->M = m;
 
    // delete any previously allocated  storage
    if (this->Value != 0)
    {
      delete[] this->Value;
    }
    if (this->Column_index != 0)
    {
      delete[] this->Column_index;
    }
    if (this->Row_start != 0)
    {
      delete[] this->Row_start;
    }
 
    // set Value
    this->Value = value;
 
    // set Column_index
    this->Column_index = column_index_;
 
    // set Row_start
    this->Row_start = row_start_;
  }

References m, n, N, and Eigen::value.

Referenced by oomph::CRDoubleMatrix::build_without_copy().

clean_up_memory()

template<class T >

void oomph::CRMatrix< T >::clean_up_memory

Wipe matrix data and set all values to 0.

////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////

  {
    // delete any previously allocated  storage
    if (this->Value != 0)
    {
      delete[] this->Value;
      this->Value = 0;
    }
    if (this->Column_index != 0)
    {
      delete[] this->Column_index;
      this->Column_index = 0;
    }
    if (this->Row_start != 0)
    {
      delete[] this->Row_start;
      this->Row_start = 0;
    }
    this->Nnz = 0;
    this->N = 0;
    this->M = 0;
  }

References N.

Referenced by oomph::CRDoubleMatrix::build(), oomph::CRDoubleMatrix::build_without_copy(), and oomph::CRDoubleMatrix::clear().

column_index() [1/2]

template<class T >

int* oomph::CRMatrix< T >::column_index ( )

inline

Access to C-style column index array.

    {
      return Column_index;
    }

References oomph::CRMatrix< T >::Column_index.

Referenced by oomph::CRDoubleMatrix::column_index(), oomph::CRMatrix< T >::CRMatrix(), oomph::CRDoubleMatrix::matrix_reduction(), oomph::CRDoubleMatrix::multiply(), and oomph::CRDoubleMatrix::multiply_transpose().

column_index() [2/2]

template<class T >

const int* oomph::CRMatrix< T >::column_index ( ) const

inline

Access to C-style column index array (const version)

    {
      return Column_index;
    }

References oomph::CRMatrix< T >::Column_index.

entry()

template<class T >

T& oomph::CRMatrix< T >::entry ( const unsigned long &  i, const unsigned long &  j  )

inline

The read-write access function is deliberately broken.

    {
      std::string error_string =
        "Non-const access not provided for the CRMatrix<T> class\n";
      error_string +=
        "It is not possible to use round-bracket access: M(i,j)\n";
      error_string += "if M is not declared as const.\n";
      error_string += "The solution (albeit ugly) is to create const reference "
                      "to the matrix\n";
      error_string += " const CRMatrix<T>& read_M = M;\n";
      error_string += "Then read_M(i,j) is permitted\n";
 
      throw OomphLibError(
        error_string, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
 
      // Dummy return
      T dummy;
      return dummy;
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

get_entry()

template<class T >

T oomph::CRMatrix< T >::get_entry ( const unsigned long &  i, const unsigned long &  j  ) const

inline

Access function that will be called by the read-only round-bracket operator (const)

    {
#ifdef RANGE_CHECKING
      this->range_check(i, j);
#endif
      for (long k = Row_start[i]; k < Row_start[i + 1]; k++)
      {
        if (unsigned(Column_index[k]) == j)
        {
          return this->Value[k];
        }
      }
      return this->Zero;
    }

References oomph::CRMatrix< T >::Column_index, i, j, k, oomph::Matrix< T, MATRIX_TYPE >::range_check(), oomph::CRMatrix< T >::Row_start, oomph::SparseMatrix< T, CRMatrix< T > >::Value, and oomph::SparseMatrix< T, CRMatrix< T > >::Zero.

Referenced by oomph::CRDoubleMatrix::diagonal_entries(), and oomph::CRDoubleMatrix::operator()().

operator=()

template<class T >

void oomph::CRMatrix< T >::operator= ( const CRMatrix< T > &  )

delete

Broken assignment operator.

output_bottom_right_zero_helper()

template<class T >

void oomph::CRMatrix< T >::output_bottom_right_zero_helper ( std::ostream &  outfile ) const

inlinevirtual

Output the "bottom right" entry regardless of it being zero or not (this allows automatic detection of matrix size in e.g. matlab, python).

Reimplemented from oomph::SparseMatrix< T, CRMatrix< T > >.

    {
      int last_row_local = this->N - 1;
      int last_col = this->M - 1;
 
      // Use this strange thingy because of the CRTP discussed above.
      T last_value = this->operator()(last_row_local, last_col);
 
      if (last_value == T(0))
      {
        outfile << last_row_local << " " << last_col << " " << T(0)
                << std::endl;
      }
    }

References oomph::SparseMatrix< T, CRMatrix< T > >::N, and oomph::Matrix< T, MATRIX_TYPE >::operator()().

Referenced by oomph::CRDoubleMatrix::output_bottom_right_zero_helper().

row_start() [1/2]

template<class T >

int* oomph::CRMatrix< T >::row_start ( )

inline

Access to C-style row_start array.

    {
      return Row_start;
    }

References oomph::CRMatrix< T >::Row_start.

Referenced by oomph::CRMatrix< T >::CRMatrix(), oomph::CRDoubleMatrix::inf_norm(), oomph::CRDoubleMatrix::matrix_reduction(), oomph::CRDoubleMatrix::multiply(), oomph::CRDoubleMatrix::multiply_transpose(), and oomph::CRDoubleMatrix::row_start().

row_start() [2/2]

template<class T >

const int* oomph::CRMatrix< T >::row_start ( ) const

inline

Access to C-style row_start array (const version)

    {
      return Row_start;
    }

References oomph::CRMatrix< T >::Row_start.

sparse_indexed_output_helper()

template<class T >

void oomph::CRMatrix< T >::sparse_indexed_output_helper ( std::ostream &  outfile ) const

inlinevirtual

Indexed output function to print a matrix to the stream outfile as i,j,a(i,j) for a(i,j)!=0 only.

Reimplemented from oomph::SparseMatrix< T, CRMatrix< T > >.

    {
      for (unsigned long i = 0; i < this->N; i++)
      {
        for (long j = Row_start[i]; j < Row_start[i + 1]; j++)
        {
          outfile << i << " " << Column_index[j] << " " << this->Value[j]
                  << std::endl;
        }
      }
    }

References oomph::CRMatrix< T >::Column_index, i, j, oomph::SparseMatrix< T, CRMatrix< T > >::N, oomph::CRMatrix< T >::Row_start, and oomph::SparseMatrix< T, CRMatrix< T > >::Value.

Referenced by oomph::CRDoubleMatrix::sparse_indexed_output_helper().

Member Data Documentation

Column_index

template<class T >

int* oomph::CRMatrix< T >::Column_index

protected

Column index.

Referenced by oomph::CRMatrix< T >::column_index(), oomph::CRMatrix< T >::CRMatrix(), oomph::CRMatrix< T >::get_entry(), oomph::CRMatrix< T >::sparse_indexed_output_helper(), and oomph::CRMatrix< T >::~CRMatrix().

Row_start

template<class T >

int* oomph::CRMatrix< T >::Row_start

protected

Start index for row.

Referenced by oomph::CRMatrix< T >::CRMatrix(), oomph::CRMatrix< T >::get_entry(), oomph::CRMatrix< T >::row_start(), oomph::CRMatrix< T >::sparse_indexed_output_helper(), and oomph::CRMatrix< T >::~CRMatrix().

---

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

• matrices.h