cDenseMatrix< DataType > Class Template Reference

Container for dense matrices. More...

#include <c_dense_matrix.h>

Inheritance diagram for cDenseMatrix< DataType >:

Collaboration diagram for cDenseMatrix< DataType >:

Public Member Functions
	cDenseMatrix ()
	Default constructor.
	cDenseMatrix (const DataType *A_, const LongIndexType num_rows_, const LongIndexType num_columns_, const FlagType A_is_row_major_, const FlagType A_is_symmetric_)
	Constructor.
virtual	~cDenseMatrix ()
	Destructor.
virtual FlagType	is_identity_matrix () const
	Checks whether the matrix is identity.
virtual void	dot (const DataType *vector, DataType *product)
	Matrix vector product.
virtual void	dot_plus (const DataType *vector, const DataType alpha, DataType *product)
	Matrix vector product written in place.
virtual void	transpose_dot (const DataType *vector, DataType *product)
	Transposed-matrix vector product.
virtual void	transpose_dot_plus (const DataType *vector, const DataType alpha, DataType *product)
	Transposed-matrix vector product written in place.
Public Member Functions inherited from cMatrix< DataType >
	cMatrix ()
	Default constructor.
	cMatrix (const FlagType A_is_symmetric_)
	Constructor.
virtual	~cMatrix ()
	Destructor.
DataType	get_eigenvalue (const DataType *known_parameters, const DataType known_eigenvalue, const DataType *inquiry_parameters) const
	This virtual function is implemented from its pure virtual function of the base class. In this class, this functio has no use and was only implemented so that this class be able to be instantiated (due to the pure virtual function).
virtual void	set_symmetry (const FlagType symmetric)
	Specify whether the matrix is symmetic or non-symmetric.
Public Member Functions inherited from cLinearOperator< DataType >
	cLinearOperator ()
	Default constructor.
virtual	~cLinearOperator ()
	Destructor.
void	set_parameters (DataType *parameters_)
	Sets the scalar parameter this->parameters. Parameter is initialized to NULL. However, before calling dot or transpose_dot functions, the parameters must be set.
Public Member Functions inherited from cLinearOperatorBase
	cLinearOperatorBase ()
	Default constructor.
	cLinearOperatorBase (const LongIndexType num_rows_, const LongIndexType num_columns_)
	Constructor with setting num_rows and num_columns.
virtual	~cLinearOperatorBase ()
	Destructor.
LongIndexType	get_num_rows () const
	Returns the number of rows of the matrix.
LongIndexType	get_num_columns () const
	Returns the number of columns of the matrix.
IndexType	get_num_parameters () const
	Returns the number of parameters of the linear operator.
FlagType	is_eigenvalue_relation_known () const
	Returns a flag that determines whether a relation between the parameters of the operator and its eigenvalue(s) is known.

Protected Attributes
const DataType *	A
const FlagType	A_is_row_major
Protected Attributes inherited from cMatrix< DataType >
FlagType	A_is_symmetric
Protected Attributes inherited from cLinearOperator< DataType >
DataType *	parameters
Protected Attributes inherited from cLinearOperatorBase
const LongIndexType	num_rows
const LongIndexType	num_columns
FlagType	eigenvalue_relation_known
IndexType	num_parameters

Detailed Description

template<typename DataType>
class cDenseMatrix< DataType >

Container for dense matrices.

The cDenseMatrix holds a two-dimensional dense matrix, and can perofrom matrix-vector product and transposed matrix-vector product.

See also

cMatrix, cCSRMatrix, cCSCMatrix, cDenseAffineMatrixFunction, cuDenseMatrix

Definition at line 43 of file c_dense_matrix.h.

Constructor & Destructor Documentation

cDenseMatrix() [1/2]

template<typename DataType >

cDenseMatrix< DataType >::cDenseMatrix

(

)

Default constructor.

Definition at line 34 of file c_dense_matrix.cpp.

                                    :
    
    // Initializer list
    A(NULL),
    A_is_row_major(0)
{
}

cDenseMatrix() [2/2]

template<typename DataType >

cDenseMatrix< DataType >::cDenseMatrix	(	const DataType *	A_,
		const LongIndexType	num_rows_,
		const LongIndexType	num_columns_,
		const FlagType	A_is_row_major_,
		const FlagType	A_is_symmetric_
	)

Constructor.

Parameters

[in]	A_	1D array that represents a 2D dense array with either C (row) major ordering or Fortran (column) major ordering. The major ordering should de defined by A_is_row_major flag.
[in]	num_rows_	Number of rows of A
[in]	num_columns_	Number of columns of A
[in]	A_is_row_major_	Boolean, can be 0 or 1 as follows: If A is row major (C ordering where the last index is contiguous) this value should be 1. If A is column major (Fortran ordering where the first index is contiguous), this value should be set to 0.
[in]	A_is_symmetric_	Boolean. If A is symmetric, set this value to 1, otherwise 0.

Definition at line 68 of file c_dense_matrix.cpp.

                                       :
 
    // Base class constructors
    cLinearOperatorBase(num_rows_, num_columns_),
    cMatrix<DataType>(A_is_symmetric_),
 
    // Initializer list
    A(A_),
    A_is_row_major(A_is_row_major_)
{
}

~cDenseMatrix()

template<typename DataType >

cDenseMatrix< DataType >::~cDenseMatrix ( )

virtual

Destructor.

Definition at line 94 of file c_dense_matrix.cpp.

{
}

Member Function Documentation

dot()

template<typename DataType >

void cDenseMatrix< DataType >::dot ( const DataType *  vector, DataType *  product  )

virtual

Matrix vector product.

Performs the matrix vector product \( \boldsymbol{y} = \mathbf{A} \boldsymbol{x} \).

Parameters

[in]	vector	A one-dimensional input vector \( \boldsymbol{x} \) with size the of the number of columns of the matrix \( \mathbf{A} \).
[out]	product	A one-dimensional output vector \( \boldsymbol{y} \) with the size of the number of rows of \( \mathbf{A} \). This vector will be overwritten.

See also

cDenseMatrix::dot_plus, cDenseMatrix::transposed_dot cDenseMatrix::transposed_dot_plus

Implements cLinearOperator< DataType >.

Definition at line 252 of file c_dense_matrix.cpp.

{
    cMatrixOperations<DataType>::dense_matvec(
            this->A,
            vector,
            this->num_rows,
            this->num_columns,
            this->A_is_row_major,
            this->A_is_symmetric,
            product);
}

References cMatrixOperations< DataType >::dense_matvec().

Here is the call graph for this function:

dot_plus()

template<typename DataType >

void cDenseMatrix< DataType >::dot_plus ( const DataType *  vector, const DataType  alpha, DataType *  product  )

virtual

Matrix vector product written in place.

Performs the matrix vector product \( \boldsymbol{y} = \boldsymbol{y} + \alpha \mathbf{A} \boldsymbol{x} \).

Parameters

[in]	vector	A one-dimensional input vector \( \boldsymbol{x} \) with size the of the number of columns of the matrix \( \mathbf{A} \).
[in]	alpha	A scalar.
[out]	product	A one-dimensional output vector \( \boldsymbol{y} \) with the size of the number of rows of \( \mathbf{A} \).

See also

cDenseMatrix::dot, cDenseMatrix::transposed_dot cDenseMatrix::transposed_dot_plus

Implements cMatrix< DataType >.

Definition at line 290 of file c_dense_matrix.cpp.

{
    cMatrixOperations<DataType>::dense_matvec_plus(
            this->A,
            vector,
            alpha,
            this->num_rows,
            this->num_columns,
            this->A_is_row_major,
            this->A_is_symmetric,
            product);
}

References cMatrixOperations< DataType >::dense_matvec_plus().

Here is the call graph for this function:

is_identity_matrix()

template<typename DataType >

FlagType cDenseMatrix< DataType >::is_identity_matrix ( ) const

virtual

Checks whether the matrix is identity.

The identity check is primarily performed in the cAffineMatrixFunction class.

Returns

Returns 1 if the input matrix is identity, and 0 otherwise.

See also

cAffineMatrixFunction

Implements cMatrix< DataType >.

Definition at line 113 of file c_dense_matrix.cpp.

{
    FlagType matrix_is_identity = 1;
    DataType matrix_element;
    const DataType diagonal = 1.0;
    const DataType off_diagonal = 0.0;
 
    // Check matrix element-wise
    if (this->A_is_row_major)
    {
        // Row-major matrix
        LongIndexType column;
        LongIndexType num_checking_columns;
 
        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
        #pragma omp parallel for \
            schedule(static) \
            if (!omp_in_parallel()) \
            default(none) \
            shared(matrix_is_identity, diagonal, off_diagonal) \
            private(column, num_checking_columns, matrix_element)
        #endif
        for (LongIndexType row=0; row < this->num_rows; ++row)
        {
            if (matrix_is_identity)
            {
                if (this->A_is_symmetric)
                {
                    // Check only half of the columns up to diagonal element
                    num_checking_columns = row + 1;
                }
                else
                {
                    num_checking_columns = this->num_columns;
                }
 
                for (column=0; column < num_checking_columns; ++column)
                {
                    // Get an element of the matrix
                    matrix_element = this->A[row * this->num_columns + column];
 
                    // Check the value of element with identity matrix
                    if (((row == column) && \
                         (!c_arithmetics::is_equal(matrix_element,
                                                   diagonal))) || \
                        ((row != column) && \
                         (!c_arithmetics::is_equal(matrix_element,
                                                   off_diagonal))))
                    {
                        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
                        #pragma omp atomic write
                        #endif
                        matrix_is_identity = 0;
 
                        break;
                    }
                }
            }
        }
    }
    else
    {
        // Column-major matrix
        LongIndexType row;
        LongIndexType num_checking_rows;
 
        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
        #pragma omp parallel for \
            schedule(static) \
            if (!omp_in_parallel()) \
            default(none) \
            shared(matrix_is_identity, diagonal, off_diagonal) \
            private(row, num_checking_rows, matrix_element)
        #endif
        for (LongIndexType column=0; column < this-> num_columns; ++column)
        {
            if (matrix_is_identity)
            {
                if (this->A_is_symmetric)
                {
                    // Check only half of the rows up to diagonal element
                    num_checking_rows = column + 1;
                }
                else
                {
                    num_checking_rows = this->num_rows;
                }
 
                for (row=0; row < num_checking_rows; ++row)
                {
                    // Get an element of the matrix
                    matrix_element = this->A[column * this->num_rows + row];
 
                    // Check the value of element with identity matrix
                    if (((row == column) && \
                         (!c_arithmetics::is_equal(matrix_element,
                                                   diagonal))) || \
                        ((row != column) && \
                         (!c_arithmetics::is_equal(matrix_element,
                                                   off_diagonal))))
                    {
                        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
                        #pragma omp atomic write
                        #endif
                        matrix_is_identity = 0;
 
                        break;
                    }
                }
            }
        }
    }
 
    return matrix_is_identity;
}

References c_arithmetics::is_equal().

Here is the call graph for this function:

transpose_dot()

template<typename DataType >

void cDenseMatrix< DataType >::transpose_dot ( const DataType *  vector, DataType *  product  )

virtual

Transposed-matrix vector product.

Performs the matrix vector product: \( \boldsymbol{y} = \mathbf{A}^{\intercal} \boldsymbol{x} \).

Parameters

[in]	vector	A one-dimensional input vector \( \boldsymbol{x} \) with size the of the number of columns of the matrix \( \mathbf{A} \).
[out]	product	A one-dimensional output vector \( \boldsymbol{y} \) with the size of the number of rows of \( \mathbf{A} \). This vector will be overwritten.

See also

cDenseMatrix::dot_plus, cDenseMatrix::dot cDenseMatrix::transposed_dot_plus

Implements cLinearOperator< DataType >.

Definition at line 329 of file c_dense_matrix.cpp.

{
    cMatrixOperations<DataType>::dense_transposed_matvec(
            this->A,
            vector,
            this->num_rows,
            this->num_columns,
            this->A_is_row_major,
            this->A_is_symmetric,
            product);
}

References cMatrixOperations< DataType >::dense_transposed_matvec().

Here is the call graph for this function:

transpose_dot_plus()

template<typename DataType >

void cDenseMatrix< DataType >::transpose_dot_plus ( const DataType *  vector, const DataType  alpha, DataType *  product  )

virtual

Transposed-matrix vector product written in place.

Performs the matrix vector product \( \boldsymbol{y} = \boldsymbol{y} + \alpha \mathbf{A}^{\intercal} \boldsymbol{x} \).

Parameters

[in]	vector	A one-dimensional input vector \( \boldsymbol{x} \) with size the of the number of columns of the matrix \( \mathbf{A} \).
[in]	alpha	A scalar.
[out]	product	A one-dimensional output vector \( \boldsymbol{y} \) with the size of the number of rows of \( \mathbf{A} \).

See also

cDenseMatrix::dot_plus, cDenseMatrix::transposed_dot cDenseMatrix::dot

Implements cMatrix< DataType >.

Definition at line 368 of file c_dense_matrix.cpp.

{
    cMatrixOperations<DataType>::dense_transposed_matvec_plus(
            this->A,
            vector,
            alpha,
            this->num_rows,
            this->num_columns,
            this->A_is_row_major,
            this->A_is_symmetric,
            product);
}

References cMatrixOperations< DataType >::dense_transposed_matvec_plus().

Here is the call graph for this function:

Member Data Documentation

A

template<typename DataType >

const DataType* cDenseMatrix< DataType >::A

protected

Definition at line 82 of file c_dense_matrix.h.

A_is_row_major

template<typename DataType >

const FlagType cDenseMatrix< DataType >::A_is_row_major

protected

Definition at line 83 of file c_dense_matrix.h.

---

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

• /home/runner/work/imate/imate/imate/_c_linear_operator/c_dense_matrix.h
• /home/runner/work/imate/imate/imate/_c_linear_operator/c_dense_matrix.cpp