oomph::CCMatrix< T > Class Template Reference

#include <matrices.h>

Inheritance diagram for oomph::CCMatrix< T >:

Public Member Functions
	CCMatrix ()
	Default constructor. More...
	CCMatrix (const Vector< T > &value, const Vector< int > &row_index_, const Vector< int > &column_start_, const unsigned long &n, const unsigned long &m)
	CCMatrix (const CCMatrix &source_matrix)
	Copy constructor. More...
void	operator= (const CCMatrix &)=delete
	Broken assignment operator. More...
virtual	~CCMatrix ()
	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)
int *	column_start ()
	Access to C-style column_start array. More...
const int *	column_start () const
	Access to C-style column_start array (const version) More...
int *	row_index ()
	Access to C-style row index array. More...
const int *	row_index () const
	Access to C-style row 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 > &row_index, const Vector< int > &column_start, const unsigned long &n, const unsigned long &m)
void	build_without_copy (T *value, int *row_index, int *column_start, const unsigned long &nnz, const unsigned long &n, const unsigned long &m)
Public Member Functions inherited from oomph::SparseMatrix< T, CCMatrix< 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 *	Row_index
	Row index. More...
int *	Column_start
	Start index for column. More...
Protected Attributes inherited from oomph::SparseMatrix< T, CCMatrix< 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, CCMatrix< T > >
static T	Zero
	Dummy zero. More...

Detailed Description

template<class T>
class oomph::CCMatrix< T >

/////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// A class for compressed column matrices: a sparse matrix format The class is passed as the MATRIX_TYPE paramater so that the base class can use the specific access functions in the round-bracket operator.

Constructor & Destructor Documentation

CCMatrix() [1/3]

template<class T >

oomph::CCMatrix< T >::CCMatrix ( )

inline

Default constructor.

               : SparseMatrix<T, CCMatrix<T>>()
    {
      Row_index = 0;
      Column_start = 0;
    }

References oomph::CCMatrix< T >::Column_start, and oomph::CCMatrix< T >::Row_index.

CCMatrix() [2/3]

template<class T >

oomph::CCMatrix< T >::CCMatrix ( const Vector< T > &  value, const Vector< int > &  row_index_, const Vector< int > &  column_start_, const unsigned long &  n, const unsigned long &  m  )

inline

Constructor: Pass vector of values, vector of row indices, vector of column starts and number of rows (can be suppressed for square matrices). Number of nonzero entries is read off from value, so make sure the vector has been shrunk to its correct length.

      : SparseMatrix<T, CCMatrix<T>>()
    {
      Row_index = 0;
      Column_start = 0;
      build(value, row_index_, column_start_, n, m);
    }

References oomph::CCMatrix< T >::build(), oomph::CCMatrix< T >::Column_start, m, n, oomph::CCMatrix< T >::Row_index, and oomph::SparseMatrix< T, CCMatrix< T > >::value().

CCMatrix() [3/3]

template<class T >

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

inline

Copy constructor.

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

References oomph::CCMatrix< T >::column_start(), oomph::CCMatrix< T >::Column_start, i, oomph::SparseMatrix< T, CCMatrix< T > >::M, oomph::SparseMatrix< T, CCMatrix< T > >::Nnz, oomph::CCMatrix< T >::row_index(), and oomph::CCMatrix< T >::Row_index.

~CCMatrix()

template<class T >

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

inlinevirtual

Destructor, delete any allocated memory.

    {
      delete[] Row_index;
      Row_index = 0;
      delete[] Column_start;
      Column_start = 0;
    }

References oomph::CCMatrix< T >::Column_start, and oomph::CCMatrix< T >::Row_index.

Member Function Documentation

build()

template<class T >

void oomph::CCMatrix< T >::build	(	const Vector< T > &	value,
		const Vector< int > &	row_index_,
		const Vector< int > &	column_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.

  {
#ifdef PARANOID
    if (value.size() != row_index_.size())
    {
      std::ostringstream error_message;
      error_message << "length of value " << value.size()
                    << " and row_index vectors " << row_index_.size()
                    << " should match " << 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->Row_index != 0)
    {
      delete[] this->Row_index;
    }
    if (this->Column_start != 0)
    {
      delete[] this->Column_start;
    }
 
    // Values stored in C-style array
    this->Value = new T[this->Nnz];
 
    // Row indices stored in C-style array
    this->Row_index = new int[this->Nnz];
 
    // Assign:
    for (unsigned long i = 0; i < this->Nnz; i++)
    {
      this->Value[i] = value[i];
      this->Row_index[i] = row_index_[i];
    }
 
    // Column start:
    // Find the size and aollcate
    unsigned long n_column_start = column_start_.size();
    this->Column_start = new int[n_column_start];
 
    // Assign:
    for (unsigned long i = 0; i < n_column_start; i++)
    {
      this->Column_start[i] = column_start_[i];
    }
  }

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

Referenced by oomph::CCMatrix< T >::CCMatrix().

build_without_copy()

template<class T >

void oomph::CCMatrix< T >::build_without_copy	(	T *	value,
		int *	row_index,
		int *	column_start,
		const unsigned long &	nnz,
		const unsigned long &	n,
		const unsigned long &	m
	)

Function to build matrix from pointers to arrays which hold the column starts, row indices and non-zero values. The final parameters specifies 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!

Build matrix from compressed representation. 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->Row_index != 0)
    {
      delete[] this->Row_index;
    }
    if (this->Column_start != 0)
    {
      delete[] this->Column_start;
    }
 
    // set Value
    this->Value = value;
 
    // set Row_index
    this->Row_index = row_index;
 
    // set Column_start
    this->Column_start = column_start;
  }

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

Referenced by oomph::Problem::get_jacobian(), and oomph::CCDoubleMatrix::multiply().

clean_up_memory()

template<class T >

void oomph::CCMatrix< 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->Row_index != 0)
    {
      delete[] this->Row_index;
      this->Row_index = 0;
    }
    if (this->Column_start != 0)
    {
      delete[] this->Column_start;
      this->Column_start = 0;
    }
    this->Nnz = 0;
    this->N = 0;
    this->M = 0;
  }

References N.

column_start() [1/2]

template<class T >

int* oomph::CCMatrix< T >::column_start ( )

inline

Access to C-style column_start array.

    {
      return Column_start;
    }

References oomph::CCMatrix< T >::Column_start.

Referenced by oomph::CCMatrix< T >::CCMatrix(), oomph::SuperLUSolver::factorise_serial(), oomph::CCDoubleMatrix::multiply(), and oomph::ILUZeroPreconditioner< CCDoubleMatrix >::setup().

column_start() [2/2]

template<class T >

const int* oomph::CCMatrix< T >::column_start ( ) const

inline

Access to C-style column_start array (const version)

    {
      return Column_start;
    }

References oomph::CCMatrix< T >::Column_start.

entry()

template<class T >

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

inline

Read-write access is not permitted for these matrices and is deliberately broken.

    {
      std::string error_string =
        "Non-const access not provided for the CCMatrix<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 CCMatrix<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::CCMatrix< 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 = Column_start[j]; k < Column_start[j + 1]; k++)
      {
        if (unsigned(Row_index[k]) == i)
        {
          return this->Value[k];
        }
      }
      return this->Zero;
    }

References oomph::CCMatrix< T >::Column_start, i, j, k, oomph::Matrix< T, MATRIX_TYPE >::range_check(), oomph::CCMatrix< T >::Row_index, oomph::SparseMatrix< T, CCMatrix< T > >::Value, and oomph::SparseMatrix< T, CCMatrix< T > >::Zero.

Referenced by oomph::CCDoubleMatrix::operator()().

operator=()

template<class T >

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

delete

Broken assignment operator.

output_bottom_right_zero_helper()

template<class T >

void oomph::CCMatrix< 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, CCMatrix< T > >.

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

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

row_index() [1/2]

template<class T >

int* oomph::CCMatrix< T >::row_index ( )

inline

Access to C-style row index array.

    {
      return Row_index;
    }

References oomph::CCMatrix< T >::Row_index.

Referenced by oomph::CCMatrix< T >::CCMatrix(), oomph::SuperLUSolver::factorise_serial(), oomph::CCDoubleMatrix::multiply(), oomph::MatrixBasedLumpedPreconditioner< MATRIX >::setup(), and oomph::ILUZeroPreconditioner< CCDoubleMatrix >::setup().

row_index() [2/2]

template<class T >

const int* oomph::CCMatrix< T >::row_index ( ) const

inline

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

    {
      return Row_index;
    }

References oomph::CCMatrix< T >::Row_index.

sparse_indexed_output_helper()

template<class T >

void oomph::CCMatrix< 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, CCMatrix< T > >.

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

References oomph::CCMatrix< T >::Column_start, j, k, oomph::SparseMatrix< T, CCMatrix< T > >::N, oomph::CCMatrix< T >::Row_index, and oomph::SparseMatrix< T, CCMatrix< T > >::Value.

Member Data Documentation

Column_start

template<class T >

int* oomph::CCMatrix< T >::Column_start

protected

Start index for column.

Referenced by oomph::CCMatrix< T >::CCMatrix(), oomph::CCMatrix< T >::column_start(), oomph::CCMatrix< T >::get_entry(), oomph::CCMatrix< T >::sparse_indexed_output_helper(), and oomph::CCMatrix< T >::~CCMatrix().

Row_index

template<class T >

int* oomph::CCMatrix< T >::Row_index

protected

Row index.

Referenced by oomph::CCMatrix< T >::CCMatrix(), oomph::CCMatrix< T >::get_entry(), oomph::CCMatrix< T >::row_index(), oomph::CCMatrix< T >::sparse_indexed_output_helper(), and oomph::CCMatrix< T >::~CCMatrix().

---

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

• matrices.h