TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization > Class Template Reference

Implementation of dense matrix view. More...

#include <TNL/Matrices/DenseMatrixView.h>

Inheritance diagram for TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >:

Collaboration diagram for TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >:

Public Types
using	ConstRowView = typename RowView::ConstRowView
	Type for accessing immutable matrix row.
using	ConstValuesViewType = typename ValuesViewType::ConstViewType
	Matrix elements container view type. More...
using	ConstViewType = DenseMatrixView< std::add_const_t< Real >, Device, Index, Organization >
	Matrix view type for constant instances. More...
using	DeviceType = Device
	The device where the matrix is allocated.
using	IndexType = Index
	The type used for matrix elements indexing.
using	RealType = Real
	The type of matrix elements.
using	RowView = DenseMatrixRowView< SegmentViewType, ValuesViewType >
	Type for accessing matrix row.
template<typename _Real = Real, typename _Device = Device, typename _Index = Index>
using	Self = DenseMatrixView< _Real, _Device, _Index >
	Helper type for getting self type or its modifications.
using	ValuesViewType = typename BaseType::ValuesView
	Matrix elements container view type. More...
using	ViewType = DenseMatrixView< Real, Device, Index, Organization >
	Matrix view type. More...
Public Types inherited from TNL::Matrices::MatrixView< Real, Device, Index >
using	ConstRowsCapacitiesTypeView = typename RowsCapacitiesTypeView::ConstViewType
using	ConstValuesView = typename ValuesView::ConstViewType
	Type of constant vector view holding values of matrix elements.
using	ConstViewType = MatrixView< typename std::add_const_t< Real >, Device, Index >
	Type of base matrix view for constant instances. More...
using	DeviceType = Device
	The device where the matrix is allocated.
using	IndexType = Index
	The type used for matrix elements indexing.
using	RealType = Real
	The type of matrix elements.
using	RowsCapacitiesType = Containers::Vector< Index, Device, Index >
using	RowsCapacitiesTypeView = Containers::VectorView< Index, Device, Index >
using	ValuesView = Containers::VectorView< Real, Device, Index >
	Type of vector view holding values of matrix elements.
using	ViewType = MatrixView< Real, Device, Index >
	Type of base matrix view. More...

Public Member Functions
__cuda_callable__	DenseMatrixView ()
	Constructor without parameters.
__cuda_callable__	DenseMatrixView (const DenseMatrixView &matrix)=default
	Copy constructor. More...
template<typename Real_ >
__cuda_callable__	DenseMatrixView (IndexType rows, IndexType columns, const Containers::VectorView< Real_, Device, Index > &values)
	Constructor with matrix dimensions and values. More...
template<typename Value_ >
__cuda_callable__	DenseMatrixView (IndexType rows, IndexType columns, const Containers::VectorView< Value_, Device, Index > &values)
__cuda_callable__	DenseMatrixView (IndexType rows, IndexType columns, const ValuesViewType &values)
	Constructor with matrix dimensions and values. More...
__cuda_callable__ void	addElement (IndexType row, IndexType column, const RealType &value, const RealType &thisElementMultiplicator=1.0)
	Add element at given row and column to given value. More...
template<typename Matrix >
void	addMatrix (const Matrix &matrix, const RealType &matrixMultiplicator=1.0, const RealType &thisMatrixMultiplicator=1.0)
template<typename Function >
void	forAllElements (Function &&function)
	This method calls forElements for all matrix rows. More...
template<typename Function >
void	forAllElements (Function &&function) const
	This method calls forElements for all matrix rows. More...
template<typename Function >
void	forAllRows (Function &&function)
	Method for parallel iteration over all matrix rows. More...
template<typename Function >
void	forAllRows (Function &&function) const
	Method for parallel iteration over all matrix rows for constant instances. More...
template<typename Function >
void	forElements (IndexType begin, IndexType end, Function &&function)
	Method for iteration over all matrix rows for non-constant instances. More...
template<typename Function >
void	forElements (IndexType begin, IndexType end, Function &&function) const
	Method for iteration over all matrix rows for constant instances. More...
template<typename Function >
void	forRows (IndexType begin, IndexType end, Function &&function)
	Method for parallel iteration over matrix rows from interval [ begin, end). More...
template<typename Function >
void	forRows (IndexType begin, IndexType end, Function &&function) const
	Method for parallel iteration over matrix rows from interval [ begin, end) for constant instances. More...
IndexType	getAllocatedElementsCount () const
	Returns number of all matrix elements. More...
template<typename Vector >
void	getCompressedRowLengths (Vector &rowLengths) const
	Computes number of non-zeros in each row. More...
__cuda_callable__ ConstViewType	getConstView () const
	Returns a non-modifiable dense matrix view. More...
__cuda_callable__ Real	getElement (IndexType row, IndexType column) const
	Returns value of matrix element at position given by its row and column index. More...
IndexType	getNonzeroElementsCount () const override
	Returns number of non-zero matrix elements. More...
__cuda_callable__ RowView	getRow (IndexType rowIdx)
	Non-constant getter of simple structure for accessing given matrix row. More...
__cuda_callable__ ConstRowView	getRow (IndexType rowIdx) const
	Constant getter of simple structure for accessing given matrix row. More...
template<typename Vector >
void	getRowCapacities (Vector &rowCapacities) const
	Compute capacities of all rows. More...
std::string	getSerializationTypeVirtual () const override
	Returns string with serialization type. More...
__cuda_callable__ ViewType	getView ()
	Returns a modifiable dense matrix view. More...
template<typename Real_ , typename Device_ , typename Index_ >
bool	operator!= (const DenseMatrixView< Real_, Device_, Index_, Organization > &matrix) const
	Comparison operator with another dense matrix view. More...
template<typename Matrix >
bool	operator!= (const Matrix &matrix) const
	Comparison operator with another arbitrary matrix type. More...
__cuda_callable__ Real &	operator() (IndexType row, IndexType column)
	Returns non-constant reference to element at row row and column column. More...
__cuda_callable__ const Real &	operator() (IndexType row, IndexType column) const
	Returns constant reference to element at row row and column column. More...
DenseMatrixView &	operator= (const DenseMatrixView &matrix)
	Assignment operator with DenseMatrix. More...
template<typename Real_ , typename Device_ , typename Index_ >
bool	operator== (const DenseMatrixView< Real_, Device_, Index_, Organization > &matrix) const
	Comparison operator with another dense matrix view. More...
template<typename Matrix >
bool	operator== (const Matrix &matrix) const
	Comparison operator with another arbitrary matrix type. More...
void	print (std::ostream &str) const override
	Method for printing the matrix to output stream. More...
template<typename Fetch , typename Reduce , typename Keep , typename FetchReal >
void	reduceAllRows (Fetch &fetch, const Reduce &reduce, Keep &keep, const FetchReal &identity)
	Method for performing general reduction on ALL matrix rows. More...
template<typename Fetch , typename Reduce , typename Keep , typename FetchReal >
void	reduceAllRows (Fetch &fetch, const Reduce &reduce, Keep &keep, const FetchReal &identity) const
	Method for performing general reduction on ALL matrix rows for constant instances. More...
template<typename Fetch , typename Reduce , typename Keep , typename FetchReal >
void	reduceRows (IndexType begin, IndexType end, Fetch &fetch, const Reduce &reduce, Keep &keep, const FetchReal &identity)
	Method for performing general reduction on matrix rows. More...
template<typename Fetch , typename Reduce , typename Keep , typename FetchReal >
void	reduceRows (IndexType begin, IndexType end, Fetch &fetch, const Reduce &reduce, Keep &keep, const FetchReal &identity) const
	Method for performing general reduction on matrix rows for constant instances. More...
template<typename Fetch , typename Reduce , typename Keep , typename FetchValue >
void	reduceRows (IndexType begin, IndexType end, Fetch &fetch, const Reduce &reduce, Keep &keep, const FetchValue &identity)
template<typename Fetch , typename Reduce , typename Keep , typename FetchValue >
void	reduceRows (IndexType begin, IndexType end, Fetch &fetch, const Reduce &reduce, Keep &keep, const FetchValue &identity) const
void	save (const String &fileName) const
	Method for saving the matrix view to the file with given filename. More...
void	save (File &file) const override
	Method for saving the matrix view to a file. More...
template<typename Function >
void	sequentialForAllRows (Function &&function)
	This method calls sequentialForRows for all matrix rows. More...
template<typename Function >
void	sequentialForAllRows (Function &&function) const
	This method calls sequentialForRows for all matrix rows (for constant instances). More...
template<typename Function >
void	sequentialForRows (IndexType begin, IndexType end, Function &&function)
	Method for sequential iteration over all matrix rows for non-constant instances. More...
template<typename Function >
void	sequentialForRows (IndexType begin, IndexType end, Function &&function) const
	Method for sequential iteration over all matrix rows for constant instances. More...
__cuda_callable__ void	setElement (IndexType row, IndexType column, const RealType &value)
	Sets element at given row and column to given value. More...
void	setValue (const RealType &v)
	Sets all matrix elements to value v. More...
template<typename InVector , typename OutVector >
void	vectorProduct (const InVector &inVector, OutVector &outVector, const RealType &matrixMultiplicator=1.0, const RealType &outVectorMultiplicator=0.0, IndexType begin=0, IndexType end=0) const
	Computes product of matrix and vector. More...
Public Member Functions inherited from TNL::Matrices::MatrixView< Real, Device, Index >
__cuda_callable__	MatrixView ()
	Basic constructor with no parameters.
__cuda_callable__	MatrixView (const MatrixView &view)=default
	Shallow copy constructor. More...
__cuda_callable__	MatrixView (IndexType rows, IndexType columns, ValuesView values)
	Constructor with matrix dimensions and matrix elements values. More...
__cuda_callable__	MatrixView (MatrixView &&view) noexcept=default
	Move constructor. More...
IndexType	getAllocatedElementsCount () const
	Tells the number of allocated matrix elements. More...
__cuda_callable__ IndexType	getColumns () const
	Returns number of matrix columns. More...
virtual IndexType	getNonzeroElementsCount () const
	Computes a current number of nonzero matrix elements. More...
__cuda_callable__ IndexType	getRows () const
	Returns number of matrix rows. More...
virtual std::string	getSerializationTypeVirtual () const =0
__cuda_callable__ ValuesView &	getValues ()
	Returns a reference to a vector with the matrix elements values. More...
__cuda_callable__ const ValuesView &	getValues () const
	Returns a constant reference to a vector with the matrix elements values. More...
template<typename Matrix >
bool	operator!= (const Matrix &matrix) const
	Comparison operator with another arbitrary matrix view type. More...
template<typename MatrixT >
bool	operator!= (const MatrixT &matrix) const
__cuda_callable__ MatrixView &	operator= (const MatrixView &view)
	Shallow copy of the matrix view. More...
template<typename Matrix >
bool	operator== (const Matrix &matrix) const
	Comparison operator with another arbitrary matrix view type. More...
template<typename MatrixT >
bool	operator== (const MatrixT &matrix) const
virtual void	print (std::ostream &str) const
	Method for printing the matrix view to output stream. More...
void	save (const String &fileName) const
	Method for saving the matrix view to a file. More...
virtual void	save (File &file) const
	Method for saving the matrix view to a file. More...

Static Public Member Functions
static constexpr ElementsOrganization	getOrganization ()
	Matrix elements organization getter. More...
static std::string	getSerializationType ()
	Returns string with serialization type. More...

Protected Types
using	BaseType = MatrixView< Real, Device, Index >
using	SegmentsType = Algorithms::Segments::Ellpack< Device, Index, typename Allocators::Default< Device >::template Allocator< Index >, Organization, 1 >
using	SegmentsViewType = typename SegmentsType::ViewType
using	SegmentViewType = typename SegmentsType::SegmentViewType

Protected Member Functions
__cuda_callable__ IndexType	getElementIndex (IndexType row, IndexType column) const

Protected Attributes
SegmentsViewType	segments
Protected Attributes inherited from TNL::Matrices::MatrixView< Real, Device, Index >
IndexType	columns
IndexType	rows
ValuesView	values

Detailed Description

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>
class TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >

Implementation of dense matrix view.

It serves as an accessor to DenseMatrix for example when passing the matrix to lambda functions. DenseMatrix view can be also created in CUDA kernels.

Template Parameters

Real	is a type of matrix elements.
Device	is a device where the matrix is allocated.
Index	is a type for indexing of the matrix elements.
MatrixElementsOrganization	tells the ordering of matrix elements in memory. It is either TNL::Algorithms::Segments::RowMajorOrder or TNL::Algorithms::Segments::ColumnMajorOrder.

See DenseMatrix.

Member Typedef Documentation

ConstValuesViewType

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

using TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::ConstValuesViewType = typename ValuesViewType::ConstViewType

Matrix elements container view type.

Use this for embedding of the matrix elements values.

ConstViewType

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

using TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::ConstViewType = DenseMatrixView< std::add_const_t< Real >, Device, Index, Organization >

Matrix view type for constant instances.

See DenseMatrixView.

ValuesViewType

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

using TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::ValuesViewType = typename BaseType::ValuesView

Matrix elements container view type.

Use this for embedding of the matrix elements values.

ViewType

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

using TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::ViewType = DenseMatrixView< Real, Device, Index, Organization >

Matrix view type.

See DenseMatrixView.

Constructor & Destructor Documentation

DenseMatrixView() [1/3]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::DenseMatrixView	(	IndexType	rows,
		IndexType	columns,
		const ValuesViewType &	values
	)

Constructor with matrix dimensions and values.

Organization of matrix elements values in

Parameters

rows	number of matrix rows.
columns	number of matrix columns.
values	is vector view with matrix elements values.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void createMatrixView()
{
   TNL::Containers::Vector< double, Device > values {
      1,  2,  3,  4,
      5,  6,  7,  8,
      9, 10, 11, 12 };
 
   /***
    * Create dense matrix view with row major order
    */
   TNL::Matrices::DenseMatrixView< double, Device, int, TNL::Algorithms::Segments::RowMajorOrder > rowMajorMatrix( 3, 4, values.getView() );
   std::cout << "Row major order matrix:" << std::endl;
   std::cout << rowMajorMatrix << std::endl;
 
   /***
    * Create dense matrix view with column major order
    */
   TNL::Matrices::DenseMatrixView< double, Device, int, TNL::Algorithms::Segments::RowMajorOrder > columnMajorMatrix( 4, 3, values.getView() );
   std::cout << "Column major order matrix:" << std::endl;
   std::cout << columnMajorMatrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Creating matrix view on host: " << std::endl;
   createMatrixView< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Creating matrix view on CUDA device: " << std::endl;
   createMatrixView< TNL::Devices::Cuda >();
#endif
}

Output

Creating matrix view on host: 
Row major order matrix:
Row: 0 ->     0:1       1:2       2:3       3:4   
Row: 1 ->     0:5       1:6       2:7       3:8   
Row: 2 ->     0:9       1:10      2:11      3:12  
Column major order matrix:
Row: 0 ->     0:1       1:2       2:3   
Row: 1 ->     0:4       1:5       2:6   
Row: 2 ->     0:7       1:8       2:9   
Row: 3 ->     0:10      1:11      2:12  
Creating matrix view on CUDA device: 
Row major order matrix:
Row: 0 ->     0:1       1:2       2:3       3:4   
Row: 1 ->     0:5       1:6       2:7       3:8   
Row: 2 ->     0:9       1:10      2:11      3:12  
Column major order matrix:
Row: 0 ->     0:1       1:2       2:3   
Row: 1 ->     0:4       1:5       2:6   
Row: 2 ->     0:7       1:8       2:9   
Row: 3 ->     0:10      1:11      2:12  

DenseMatrixView() [2/3]

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

template<typename Real_ >

__cuda_callable__ TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::DenseMatrixView	(	IndexType	rows,
		IndexType	columns,
		const Containers::VectorView< Real_, Device, Index > &	values
	)

Constructor with matrix dimensions and values.

Organization of matrix elements values in

Parameters

rows	number of matrix rows.
columns	number of matrix columns.
values	is vector view with matrix elements values.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void createMatrixView()
{
   TNL::Containers::Vector< double, Device > values {
      1,  2,  3,  4,
      5,  6,  7,  8,
      9, 10, 11, 12 };
 
   /***
    * Create dense matrix view with row major order
    */
   TNL::Matrices::DenseMatrixView< double, Device, int, TNL::Algorithms::Segments::RowMajorOrder > rowMajorMatrix( 3, 4, values.getView() );
   std::cout << "Row major order matrix:" << std::endl;
   std::cout << rowMajorMatrix << std::endl;
 
   /***
    * Create dense matrix view with column major order
    */
   TNL::Matrices::DenseMatrixView< double, Device, int, TNL::Algorithms::Segments::RowMajorOrder > columnMajorMatrix( 4, 3, values.getView() );
   std::cout << "Column major order matrix:" << std::endl;
   std::cout << columnMajorMatrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Creating matrix view on host: " << std::endl;
   createMatrixView< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Creating matrix view on CUDA device: " << std::endl;
   createMatrixView< TNL::Devices::Cuda >();
#endif
}

Output

Creating matrix view on host: 
Row major order matrix:
Row: 0 ->     0:1       1:2       2:3       3:4   
Row: 1 ->     0:5       1:6       2:7       3:8   
Row: 2 ->     0:9       1:10      2:11      3:12  
Column major order matrix:
Row: 0 ->     0:1       1:2       2:3   
Row: 1 ->     0:4       1:5       2:6   
Row: 2 ->     0:7       1:8       2:9   
Row: 3 ->     0:10      1:11      2:12  
Creating matrix view on CUDA device: 
Row major order matrix:
Row: 0 ->     0:1       1:2       2:3       3:4   
Row: 1 ->     0:5       1:6       2:7       3:8   
Row: 2 ->     0:9       1:10      2:11      3:12  
Column major order matrix:
Row: 0 ->     0:1       1:2       2:3   
Row: 1 ->     0:4       1:5       2:6   
Row: 2 ->     0:7       1:8       2:9   
Row: 3 ->     0:10      1:11      2:12  

DenseMatrixView() [3/3]

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

__cuda_callable__ TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::DenseMatrixView ( const DenseMatrixView< Real, Device, Index, Organization > &  matrix )

default

Copy constructor.

Parameters

matrix

is the source matrix view.

Member Function Documentation

addElement()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::addElement	(	IndexType	row,
		IndexType	column,
		const RealType &	value,
		const RealType &	thisElementMultiplicator = 1.0
	)

Add element at given row and column to given value.

This method can be called from the host system (CPU) no matter where the matrix is allocated. If the matrix is allocated on GPU this method can be called even from device kernels. If the matrix is allocated in GPU device this method is called from CPU, it transfers values of each matrix element separately and so the performance is very low. For higher performance see. DenseMatrix::getRow or DenseMatrix::forElements and DenseMatrix::forAllElements.

Parameters

row	is row index of the element.
column	is columns index of the element.
value	is the value the element will be set to.
thisElementMultiplicator	is multiplicator the original matrix element value is multiplied by before addition of given value.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
 
template< typename Device >
void addElements()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix( 5, 5 );
   auto matrixView = matrix.getView();
 
   for( int i = 0; i < 5; i++ )
      matrixView.setElement( i, i, i );
 
   std::cout << "Initial matrix is: " << std::endl << matrix << std::endl;
 
   for( int i = 0; i < 5; i++ )
      for( int j = 0; j < 5; j++ )
         matrixView.addElement( i, j, 1.0, 5.0 );
 
   std::cout << "Matrix after addition is: " << std::endl << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Add elements on host:" << std::endl;
   addElements< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Add elements on CUDA device:" << std::endl;
   addElements< TNL::Devices::Cuda >();
#endif
}

Output

Add elements on host:
Initial matrix is: 
Row: 0 ->     0:0       1:0       2:0       3:0       4:0   
Row: 1 ->     0:0       1:1       2:0       3:0       4:0   
Row: 2 ->     0:0       1:0       2:2       3:0       4:0   
Row: 3 ->     0:0       1:0       2:0       3:3       4:0   
Row: 4 ->     0:0       1:0       2:0       3:0       4:4   
Matrix after addition is: 
Row: 0 ->     0:1       1:1       2:1       3:1       4:1   
Row: 1 ->     0:1       1:6       2:1       3:1       4:1   
Row: 2 ->     0:1       1:1       2:11      3:1       4:1   
Row: 3 ->     0:1       1:1       2:1       3:16      4:1   
Row: 4 ->     0:1       1:1       2:1       3:1       4:21  
Add elements on CUDA device:
Initial matrix is: 
Row: 0 ->     0:0       1:0       2:0       3:0       4:0   
Row: 1 ->     0:0       1:1       2:0       3:0       4:0   
Row: 2 ->     0:0       1:0       2:2       3:0       4:0   
Row: 3 ->     0:0       1:0       2:0       3:3       4:0   
Row: 4 ->     0:0       1:0       2:0       3:0       4:4   
Matrix after addition is: 
Row: 0 ->     0:1       1:1       2:1       3:1       4:1   
Row: 1 ->     0:1       1:6       2:1       3:1       4:1   
Row: 2 ->     0:1       1:1       2:11      3:1       4:1   
Row: 3 ->     0:1       1:1       2:1       3:16      4:1   
Row: 4 ->     0:1       1:1       2:1       3:1       4:21  

forAllElements() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::forAllElements

(

Function &&

function

)

This method calls forElements for all matrix rows.

See DenseMatrix::forAllElements.

Template Parameters

Function

is a type of lambda function that will operate on matrix elements.

Parameters

function

is an instance of the lambda function to be called in each row.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void forAllElementsExample()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix( 5, 5 );
 
   auto f = [=] __cuda_callable__ ( int rowIdx, int columnIdx, int columnIdx_, double& value ) {
      if( rowIdx >= columnIdx )
         value = rowIdx + columnIdx;
   };
 
   matrix.forAllElements( f );
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Creating matrix on host: " << std::endl;
   forAllElementsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Creating matrix on CUDA device: " << std::endl;
   forAllElementsExample< TNL::Devices::Cuda >();
#endif
}

Output

Creating matrix on host: 
Row: 0 ->     0:0       1:0       2:0       3:0       4:0   
Row: 1 ->     0:1       1:2       2:0       3:0       4:0   
Row: 2 ->     0:2       1:3       2:4       3:0       4:0   
Row: 3 ->     0:3       1:4       2:5       3:6       4:0   
Row: 4 ->     0:4       1:5       2:6       3:7       4:8   
Creating matrix on CUDA device: 
Row: 0 ->     0:0       1:0       2:0       3:0       4:0   
Row: 1 ->     0:1       1:2       2:0       3:0       4:0   
Row: 2 ->     0:2       1:3       2:4       3:0       4:0   
Row: 3 ->     0:3       1:4       2:5       3:6       4:0   
Row: 4 ->     0:4       1:5       2:6       3:7       4:8   

forAllElements() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::forAllElements

(

Function &&

function

)

const

This method calls forElements for all matrix rows.

See DenseMatrix::forElements.

Template Parameters

Function

is a type of lambda function that will operate on matrix elements.

Parameters

function

is an instance of the lambda function to be called in each row.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void forAllElementsExample()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix( 5, 5 );
   auto matrixView = matrix.getView();
 
   auto f = [=] __cuda_callable__ ( int rowIdx, int columnIdx, int globalIdx, double& value ) {
      if( rowIdx >= columnIdx )
         value = rowIdx + columnIdx;
   };
 
   matrixView.forAllElements( f );
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Creating matrix on host: " << std::endl;
   forAllElementsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Creating matrix on CUDA device: " << std::endl;
   forAllElementsExample< TNL::Devices::Cuda >();
#endif
}

Output

Creating matrix on host: 
Row: 0 ->     0:0       1:0       2:0       3:0       4:0   
Row: 1 ->     0:1       1:2       2:0       3:0       4:0   
Row: 2 ->     0:2       1:3       2:4       3:0       4:0   
Row: 3 ->     0:3       1:4       2:5       3:6       4:0   
Row: 4 ->     0:4       1:5       2:6       3:7       4:8   
Creating matrix on CUDA device: 
Row: 0 ->     0:0       1:0       2:0       3:0       4:0   
Row: 1 ->     0:1       1:2       2:0       3:0       4:0   
Row: 2 ->     0:2       1:3       2:4       3:0       4:0   
Row: 3 ->     0:3       1:4       2:5       3:6       4:0   
Row: 4 ->     0:4       1:5       2:6       3:7       4:8   

forAllRows() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::forAllRows

(

Function &&

function

)

Method for parallel iteration over all matrix rows.

In each row, given lambda function is performed. Each row is processed by at most one thread unlike the method DenseMatrixView::forAllElements where more than one thread can be mapped to each row.

Template Parameters

Function

is type of the lambda function.

Parameters

function

is an instance of the lambda function to be called for each row.

auto function = [] __cuda_callable__ ( RowView& row ) mutable { ... };

RowView represents matrix row - see TNL::Matrices::DenseMatrixView::RowView.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void forRowsExample()
{
   using MatrixType = TNL::Matrices::DenseMatrix< double, Device >;
   using RowView = typename MatrixType::RowView;
   const int size = 5;
   MatrixType matrix( size, size );
   auto view = matrix.getView();
 
   /***
    * Set the matrix elements.
    */
   auto f = [=] __cuda_callable__ ( RowView& row ) mutable {
      const int& rowIdx = row.getRowIndex();
      if( rowIdx > 0 )
         row.setValue( rowIdx - 1, -1.0 );
      row.setValue( rowIdx, rowIdx + 1.0 );
      if( rowIdx < size - 1 )
         row.setValue( rowIdx + 1, -1.0 );
   };
   view.forAllRows( f );
   std::cout << matrix << std::endl;
 
   /***
    * Now divide each matrix row by its largest element - with the use of iterators.
    */
   view.forAllRows( [=] __cuda_callable__ ( RowView& row ) mutable {
      double largest = std::numeric_limits< double >::lowest();
      for( auto element : row )
         largest = TNL::max( largest, element.value() );
      for( auto element : row )
         element.value() /= largest;
   } );
   std::cout << "Divide each matrix row by its largest element... " << std::endl;
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting matrix rows on host: " << std::endl;
   forRowsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting matrix rows on CUDA device: " << std::endl;
   forRowsExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting matrix rows on host: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   
Getting matrix rows on CUDA device: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   

forAllRows() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::forAllRows

(

Function &&

function

)

const

Method for parallel iteration over all matrix rows for constant instances.

In each row, given lambda function is performed. Each row is processed by at most one thread unlike the method DenseMatrixView::forAllElements where more than one thread can be mapped to each row.

Template Parameters

Function

is type of the lambda function.

Parameters

function

is an instance of the lambda function to be called for each row.

auto function = [] __cuda_callable__ ( RowView& row ) { ... };

RowView represents matrix row - see TNL::Matrices::DenseMatrixView::RowView.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void forRowsExample()
{
   using MatrixType = TNL::Matrices::DenseMatrix< double, Device >;
   using RowView = typename MatrixType::RowView;
   const int size = 5;
   MatrixType matrix( size, size );
   auto view = matrix.getView();
 
   /***
    * Set the matrix elements.
    */
   auto f = [=] __cuda_callable__ ( RowView& row ) mutable {
      const int& rowIdx = row.getRowIndex();
      if( rowIdx > 0 )
         row.setValue( rowIdx - 1, -1.0 );
      row.setValue( rowIdx, rowIdx + 1.0 );
      if( rowIdx < size - 1 )
         row.setValue( rowIdx + 1, -1.0 );
   };
   view.forAllRows( f );
   std::cout << matrix << std::endl;
 
   /***
    * Now divide each matrix row by its largest element - with the use of iterators.
    */
   view.forAllRows( [=] __cuda_callable__ ( RowView& row ) mutable {
      double largest = std::numeric_limits< double >::lowest();
      for( auto element : row )
         largest = TNL::max( largest, element.value() );
      for( auto element : row )
         element.value() /= largest;
   } );
   std::cout << "Divide each matrix row by its largest element... " << std::endl;
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting matrix rows on host: " << std::endl;
   forRowsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting matrix rows on CUDA device: " << std::endl;
   forRowsExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting matrix rows on host: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   
Getting matrix rows on CUDA device: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   

forElements() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::forElements	(	IndexType	begin,
		IndexType	end,
		Function &&	function
	)

Method for iteration over all matrix rows for non-constant instances.

Template Parameters

Function

is type of lambda function that will operate on matrix elements. It is should have form like

auto function = [=] __cuda_callable__ ( IndexType rowIdx, IndexType columnIdx, IndexType columnIdx, RealType& value ) {
... };

The column index repeats twice only for compatibility with sparse matrices.

Parameters

begin	defines beginning of the range [begin,end) of rows to be processed.
end	defines ending of the range [begin,end) of rows to be processed.
function	is an instance of the lambda function to be called in each row.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void forRowsExample()
{
   using MatrixType = TNL::Matrices::DenseMatrix< double, Device >;
   using RowView = typename MatrixType::RowView;
   const int size = 5;
   MatrixType matrix( size, size );
   auto view = matrix.getView();
 
   /***
    * Set the matrix elements.
    */
   auto f = [=] __cuda_callable__ ( RowView& row ) mutable {
      const int& rowIdx = row.getRowIndex();
      if( rowIdx > 0 )
         row.setValue( rowIdx - 1, -1.0 );
      row.setValue( rowIdx, rowIdx + 1.0 );
      if( rowIdx < size - 1 )
         row.setValue( rowIdx + 1, -1.0 );
   };
   view.forAllRows( f );
   std::cout << matrix << std::endl;
 
   /***
    * Now divide each matrix row by its largest element - with the use of iterators.
    */
   view.forAllRows( [=] __cuda_callable__ ( RowView& row ) mutable {
      double largest = std::numeric_limits< double >::lowest();
      for( auto element : row )
         largest = TNL::max( largest, element.value() );
      for( auto element : row )
         element.value() /= largest;
   } );
   std::cout << "Divide each matrix row by its largest element... " << std::endl;
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting matrix rows on host: " << std::endl;
   forRowsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting matrix rows on CUDA device: " << std::endl;
   forRowsExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting matrix rows on host: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   
Getting matrix rows on CUDA device: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   

forElements() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::forElements	(	IndexType	begin,
		IndexType	end,
		Function &&	function
	)		const

Method for iteration over all matrix rows for constant instances.

Template Parameters

Function

is type of lambda function that will operate on matrix elements. It is should have form like

auto function = [=] __cuda_callable__ ( IndexType rowIdx, IndexType columnIdx, IndexType columnIdx, const RealType& value
) { ... };

The column index repeats twice only for compatibility with sparse matrices.

Parameters

begin	defines beginning of the range [begin,end) of rows to be processed.
end	defines ending of the range [begin,end) of rows to be processed.
function	is an instance of the lambda function to be called in each row.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void forRowsExample()
{
   using MatrixType = TNL::Matrices::DenseMatrix< double, Device >;
   using RowView = typename MatrixType::RowView;
   const int size = 5;
   MatrixType matrix( size, size );
   auto view = matrix.getView();
 
   /***
    * Set the matrix elements.
    */
   auto f = [=] __cuda_callable__ ( RowView& row ) mutable {
      const int& rowIdx = row.getRowIndex();
      if( rowIdx > 0 )
         row.setValue( rowIdx - 1, -1.0 );
      row.setValue( rowIdx, rowIdx + 1.0 );
      if( rowIdx < size - 1 )
         row.setValue( rowIdx + 1, -1.0 );
   };
   view.forAllRows( f );
   std::cout << matrix << std::endl;
 
   /***
    * Now divide each matrix row by its largest element - with the use of iterators.
    */
   view.forAllRows( [=] __cuda_callable__ ( RowView& row ) mutable {
      double largest = std::numeric_limits< double >::lowest();
      for( auto element : row )
         largest = TNL::max( largest, element.value() );
      for( auto element : row )
         element.value() /= largest;
   } );
   std::cout << "Divide each matrix row by its largest element... " << std::endl;
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting matrix rows on host: " << std::endl;
   forRowsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting matrix rows on CUDA device: " << std::endl;
   forRowsExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting matrix rows on host: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   
Getting matrix rows on CUDA device: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   

forRows() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::forRows	(	IndexType	begin,
		IndexType	end,
		Function &&	function
	)

Method for parallel iteration over matrix rows from interval [ begin, end).

In each row, given lambda function is performed. Each row is processed by at most one thread unlike the method DenseMatrix::forElements where more than one thread can be mapped to each row.

Template Parameters

Function

is type of the lambda function.

Parameters

begin	defines beginning of the range [ begin,end ) of rows to be processed.
end	defines ending of the range [ begin, end ) of rows to be processed.
function	is an instance of the lambda function to be called for each row.

auto function = [] __cuda_callable__ ( RowView& row ) mutable { ... };

RowView represents matrix row - see TNL::Matrices::DenseMatrix::RowView.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void forRowsExample()
{
   using MatrixType = TNL::Matrices::DenseMatrix< double, Device >;
   using RowView = typename MatrixType::RowView;
   const int size = 5;
   MatrixType matrix( size, size );
 
   /***
    * Set the matrix elements.
    */
   auto f = [=] __cuda_callable__ ( RowView& row ) mutable {
      const int& rowIdx = row.getRowIndex();
      if( rowIdx > 0 )
         row.setValue( rowIdx - 1, -1.0 );
      row.setValue( rowIdx, rowIdx + 1.0 );
      if( rowIdx < size - 1 )
         row.setValue( rowIdx + 1, -1.0 );
   };
   matrix.forAllRows( f );
   std::cout << matrix << std::endl;
 
   /***
    * Now divide each matrix row by its largest element with use of iterators.
    */
   matrix.forAllRows( [=] __cuda_callable__ ( RowView& row ) mutable {
      double largest = std::numeric_limits< double >::lowest();
      for( auto element : row )
         largest = TNL::max( largest, element.value() );
      for( auto element : row )
         element.value() /= largest;
   } );
   std::cout << "Divide each matrix row by its largest element... " << std::endl;
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting matrix rows on host: " << std::endl;
   forRowsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting matrix rows on CUDA device: " << std::endl;
   forRowsExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting matrix rows on host: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   
Getting matrix rows on CUDA device: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   

forRows() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::forRows	(	IndexType	begin,
		IndexType	end,
		Function &&	function
	)		const

Method for parallel iteration over matrix rows from interval [ begin, end) for constant instances.

In each row, given lambda function is performed. Each row is processed by at most one thread unlike the method DenseMatrixView::forElements where more than one thread can be mapped to each row.

Template Parameters

Function

is type of the lambda function.

Parameters

begin	defines beginning of the range [ begin,end ) of rows to be processed.
end	defines ending of the range [ begin, end ) of rows to be processed.
function	is an instance of the lambda function to be called for each row.

auto function = [] __cuda_callable__ ( RowView& row ) { ... };

RowView represents matrix row - see TNL::Matrices::DenseMatrixView::RowView.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void forRowsExample()
{
   using MatrixType = TNL::Matrices::DenseMatrix< double, Device >;
   using RowView = typename MatrixType::RowView;
   const int size = 5;
   MatrixType matrix( size, size );
   auto view = matrix.getView();
 
   /***
    * Set the matrix elements.
    */
   auto f = [=] __cuda_callable__ ( RowView& row ) mutable {
      const int& rowIdx = row.getRowIndex();
      if( rowIdx > 0 )
         row.setValue( rowIdx - 1, -1.0 );
      row.setValue( rowIdx, rowIdx + 1.0 );
      if( rowIdx < size - 1 )
         row.setValue( rowIdx + 1, -1.0 );
   };
   view.forAllRows( f );
   std::cout << matrix << std::endl;
 
   /***
    * Now divide each matrix row by its largest element - with the use of iterators.
    */
   view.forAllRows( [=] __cuda_callable__ ( RowView& row ) mutable {
      double largest = std::numeric_limits< double >::lowest();
      for( auto element : row )
         largest = TNL::max( largest, element.value() );
      for( auto element : row )
         element.value() /= largest;
   } );
   std::cout << "Divide each matrix row by its largest element... " << std::endl;
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting matrix rows on host: " << std::endl;
   forRowsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting matrix rows on CUDA device: " << std::endl;
   forRowsExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting matrix rows on host: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   
Getting matrix rows on CUDA device: 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-1      1:2       2:-1      3:0       4:0   
Row: 2 ->     0:0       1:-1      2:3       3:-1      4:0   
Row: 3 ->     0:0       1:0       2:-1      3:4       4:-1  
Row: 4 ->     0:0       1:0       2:0       3:-1      4:5   
Divide each matrix row by its largest element... 
Row: 0 ->     0:1       1:-1      2:0       3:0       4:0   
Row: 1 ->     0:-0.5    1:1       2:-0.5    3:0       4:0   
Row: 2 ->     0:0      1:-0.333333    2:1      3:-0.333333    4:0   
Row: 3 ->     0:0       1:0      2:-0.25    3:1      4:-0.25
Row: 4 ->     0:0       1:0       2:0       3:-0.2    4:1   

getAllocatedElementsCount()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

Index TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getAllocatedElementsCount

Returns number of all matrix elements.

This method is here mainly for compatibility with sparse matrices since the number of all matrix elements is just number of rows times number of columns.

Returns

number of all matrix elements.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void getElementsCountExample()
{
   TNL::Matrices::DenseMatrix< double, Device > triangularMatrix {
      {  1 },
      {  2,  3 },
      {  4,  5,  6 },
      {  7,  8,  9, 10 },
      { 11, 12, 13, 14, 15 }
   };
   auto triangularMatrixView = triangularMatrix.getConstView();
   
   std::cout << "Matrix elements count is " << triangularMatrixView.getAllocatedElementsCount() << "." << std::endl;
   std::cout << "Non-zero matrix elements count is " << triangularMatrixView.getNonzeroElementsCount() << "." << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Computing matrix elements on host: " << std::endl;
   getElementsCountExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Computing matrix elements on CUDA device: " << std::endl;
   getElementsCountExample< TNL::Devices::Cuda >();
#endif
}

Output

Computing matrix elements on host: 
Matrix elements count is 25.
Non-zero matrix elements count is 15.
Computing matrix elements on CUDA device: 
Matrix elements count is 25.
Non-zero matrix elements count is 15.

getCompressedRowLengths()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Vector >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getCompressedRowLengths

(

Vector &

rowLengths

)

const

Computes number of non-zeros in each row.

Parameters

rowLengths

is a vector into which the number of non-zeros in each row will be stored.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void getCompressedRowLengthsExample()
{
   TNL::Matrices::DenseMatrix< double, Device > denseMatrix {
      {  1 },
      {  2,  3 },
      {  4,  5,  6 },
      {  7,  8,  9, 10 },
      { 11, 12, 13, 14, 15 }
   };
   auto denseMatrixView = denseMatrix.getConstView();
 
   std::cout << denseMatrixView << std::endl;
 
   TNL::Containers::Vector< int, Device > rowLengths;
   denseMatrixView.getCompressedRowLengths( rowLengths );
 
   std::cout << "Compressed row lengths are: " << rowLengths << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting compressed row lengths on host: " << std::endl;
   getCompressedRowLengthsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting compressed row lengths on CUDA device: " << std::endl;
   getCompressedRowLengthsExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting compressed row lengths on host: 
Row: 0 ->     0:1       1:0       2:0       3:0       4:0   
Row: 1 ->     0:2       1:3       2:0       3:0       4:0   
Row: 2 ->     0:4       1:5       2:6       3:0       4:0   
Row: 3 ->     0:7       1:8       2:9       3:10      4:0   
Row: 4 ->     0:11      1:12      2:13      3:14      4:15  
Compressed row lengths are: [ 1, 2, 3, 4, 5 ]
Getting compressed row lengths on CUDA device: 
Row: 0 ->     0:1       1:0       2:0       3:0       4:0   
Row: 1 ->     0:2       1:3       2:0       3:0       4:0   
Row: 2 ->     0:4       1:5       2:6       3:0       4:0   
Row: 3 ->     0:7       1:8       2:9       3:10      4:0   
Row: 4 ->     0:11      1:12      2:13      3:14      4:15  
Compressed row lengths are: [ 1, 2, 3, 4, 5 ]

getConstView()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ auto TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getConstView

Returns a non-modifiable dense matrix view.

Returns

dense matrix view.

getElement()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ Real TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getElement	(	IndexType	row,
		IndexType	column
	)		const

Returns value of matrix element at position given by its row and column index.

This method can be called from the host system (CPU) no matter where the matrix is allocated. If the matrix is allocated on GPU this method can be called even from device kernels. If the matrix is allocated in GPU device this method is called from CPU, it transfers values of each matrix element separately and so the performance is very low. For higher performance see. DenseMatrix::getRow or DenseMatrix::forElements and DenseMatrix::forAllElements.

Parameters

row	is a row index of the matrix element.
column	i a column index of the matrix element.

Returns

value of given matrix element.

Example

#include <iostream>
#include <iomanip>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
 
template< typename Device >
void getElements()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix {
      {  1,  0,  0,  0,  0 },
      { -1,  2, -1,  0,  0 },
      {  0, -1,  2, -1,  0 },
      {  0,  0, -1,  2, -1 },
      {  0,  0,  0,  0,  1 } };
   auto matrixView = matrix.getConstView();
 
 
   for( int i = 0; i < 5; i++ )
   {
      for( int j = 0; j < 5; j++ )
         std::cout << std::setw( 5 ) << std::ios::right << matrixView.getElement( i, i );
      std::cout << std::endl;
   }
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Get elements on host:" << std::endl;
   getElements< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Get elements on CUDA device:" << std::endl;
   getElements< TNL::Devices::Cuda >();
#endif
}

Output

Get elements on host:
    1    0    0    0    0
   -1    2   -1    0    0
    0   -1    2   -1    0
    0    0   -1    2   -1
    0    0    0    0    1
Get elements on CUDA device:
    1    0    0    0    0
   -1    2   -1    0    0
    0   -1    2   -1    0
    0    0   -1    2   -1
    0    0    0    0    1

getNonzeroElementsCount()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

Index TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getNonzeroElementsCount

overridevirtual

Returns number of non-zero matrix elements.

Returns

number of all non-zero matrix elements.

Example

#include <iostream>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void getElementsCountExample()
{
   TNL::Matrices::DenseMatrix< double, Device > triangularMatrix {
      {  1 },
      {  2,  3 },
      {  4,  5,  6 },
      {  7,  8,  9, 10 },
      { 11, 12, 13, 14, 15 }
   };
   auto triangularMatrixView = triangularMatrix.getConstView();
   
   std::cout << "Matrix elements count is " << triangularMatrixView.getAllocatedElementsCount() << "." << std::endl;
   std::cout << "Non-zero matrix elements count is " << triangularMatrixView.getNonzeroElementsCount() << "." << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Computing matrix elements on host: " << std::endl;
   getElementsCountExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Computing matrix elements on CUDA device: " << std::endl;
   getElementsCountExample< TNL::Devices::Cuda >();
#endif
}

Output

Computing matrix elements on host: 
Matrix elements count is 25.
Non-zero matrix elements count is 15.
Computing matrix elements on CUDA device: 
Matrix elements count is 25.
Non-zero matrix elements count is 15.

Reimplemented from TNL::Matrices::MatrixView< Real, Device, Index >.

getOrganization()

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

static constexpr ElementsOrganization TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getOrganization ( )

inlinestaticconstexpr

Matrix elements organization getter.

Returns

matrix elements organization - RowMajorOrder of ColumnMajorOrder.

getRow() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ auto TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getRow

(

IndexType

rowIdx

)

Non-constant getter of simple structure for accessing given matrix row.

Parameters

rowIdx

is matrix row index.

Returns

RowView for accessing given matrix row.

Example

#include <iostream>
#include <TNL/Algorithms/parallelFor.h>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void getRowExample()
{
   const int size = 5;
   TNL::Matrices::DenseMatrix< double, Device > matrix( size, size );
 
   /***
    * Create dense matrix view which can be captured by the following lambda
    * function.
    */
   auto matrixView = matrix.getView();
 
   auto f = [=] __cuda_callable__ ( int rowIdx ) mutable {
      auto row = matrixView.getRow( rowIdx );
      if( rowIdx > 0 )
         row.setValue( rowIdx - 1, -1.0 );
      row.setValue( rowIdx, rowIdx + 1.0 );
      if( rowIdx < size - 1 )
         row.setValue( rowIdx + 1, -1.0 );
   };
 
   /***
    * Set the matrix elements.
    */
   TNL::Algorithms::parallelFor< Device >( 0, matrix.getRows(), f );
   std::cout << matrix << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting matrix rows on host: " << std::endl;
   getRowExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting matrix rows on CUDA device: " << std::endl;
   getRowExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting matrix rows on host: 
1
Getting matrix rows on CUDA device: 
1

See DenseMatrixRowView.

getRow() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ auto TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getRow

(

IndexType

rowIdx

)

const

Constant getter of simple structure for accessing given matrix row.

Parameters

rowIdx

is matrix row index.

Returns

RowView for accessing given matrix row.

Example

#include <iostream>
#include <functional>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void getRowExample()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix {
      { 1, 0, 0, 0, 0 },
      { 1, 2, 0, 0, 0 },
      { 1, 2, 3, 0, 0 },
      { 1, 2, 3, 4, 0 },
      { 1, 2, 3, 4, 5 }
   };
 
   /***
    * We need a matrix view to pass the matrix to lambda function even on CUDA device.
    */
   const auto matrixView = matrix.getConstView();
 
   /***
    * Fetch lambda function returns diagonal element in each row.
    */
   auto fetch = [=] __cuda_callable__ ( int rowIdx ) mutable -> double {
      auto row = matrixView.getRow( rowIdx );
      return row.getValue( rowIdx );
   };
 
   int trace = TNL::Algorithms::reduce< Device >( 0, matrix.getRows(), fetch, std::plus<>{}, 0 );
   std::cout << "Matrix trace is " << trace << "." << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Getting matrix rows on host: " << std::endl;
   getRowExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Getting matrix rows on CUDA device: " << std::endl;
   getRowExample< TNL::Devices::Cuda >();
#endif
}

Output

Getting matrix rows on host: 
Matrix trace is 15.
Getting matrix rows on CUDA device: 
Matrix trace is 15.

See DenseMatrixRowView.

getRowCapacities()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Vector >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getRowCapacities

(

Vector &

rowCapacities

)

const

Compute capacities of all rows.

The row capacities are not stored explicitly and must be computed.

Parameters

rowCapacities

is a vector where the row capacities will be stored.

getSerializationType()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

std::string TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getSerializationType

static

Returns string with serialization type.

The string has a form `MatricesDenseMatrix< RealType, [any_device], IndexType, [any_allocator], true/false >`.

Returns

String with the serialization type.

getSerializationTypeVirtual()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

std::string TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getSerializationTypeVirtual

overridevirtual

Returns string with serialization type.

See DenseMatrixView::getSerializationType.

Returns

String with the serialization type.

Implements TNL::Matrices::MatrixView< Real, Device, Index >.

getView()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ auto TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::getView

Returns a modifiable dense matrix view.

Returns

dense matrix view.

operator!=() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Real_ , typename Device_ , typename Index_ >

bool TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::operator!=

(

const DenseMatrixView< Real_, Device_, Index_, Organization > &

matrix

)

const

Comparison operator with another dense matrix view.

Parameters

matrix

is the right-hand side matrix.

Returns

false if the RHS matrix view is equal, true otherwise.

operator!=() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Matrix >

bool TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::operator!=

(

const Matrix &

matrix

)

const

Comparison operator with another arbitrary matrix type.

Parameters

matrix

is the right-hand side matrix.

Returns

true if the RHS matrix is equal, false otherwise.

operator()() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ Real & TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::operator()	(	IndexType	row,
		IndexType	column
	)

Returns non-constant reference to element at row row and column column.

Since this method returns reference to the element, it cannot be called across different address spaces. It means that it can be called only form CPU if the matrix is allocated on CPU or only from GPU kernels if the matrix is allocated on GPU.

Parameters

row	is a row index of the element.
column	is a columns index of the element.

Returns

reference to given matrix element.

operator()() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ const Real & TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::operator()	(	IndexType	row,
		IndexType	column
	)		const

Returns constant reference to element at row row and column column.

Since this method returns reference to the element, it cannot be called across different address spaces. It means that it can be called only form CPU if the matrix is allocated on CPU or only from GPU kernels if the matrix is allocated on GPU.

Parameters

row	is a row index of the element.
column	is a columns index of the element.

Returns

reference to given matrix element.

operator=()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

DenseMatrixView< Real, Device, Index, Organization > & TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::operator=

(

const DenseMatrixView< Real, Device, Index, Organization > &

matrix

)

Assignment operator with DenseMatrix.

Parameters

matrix

is the right-hand side matrix.

Returns

reference to this matrix.

operator==() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Real_ , typename Device_ , typename Index_ >

bool TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::operator==

(

const DenseMatrixView< Real_, Device_, Index_, Organization > &

matrix

)

const

Comparison operator with another dense matrix view.

Parameters

matrix

is the right-hand side matrix view.

Returns

true if the RHS matrix view is equal, false otherwise.

operator==() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Matrix >

bool TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::operator==

(

const Matrix &

matrix

)

const

Comparison operator with another arbitrary matrix type.

Parameters

matrix

is the right-hand side matrix.

Returns

true if the RHS matrix is equal, false otherwise.

print()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::print ( std::ostream &  str ) const

overridevirtual

Method for printing the matrix to output stream.

Parameters

str	is the output stream.

Reimplemented from TNL::Matrices::MatrixView< Real, Device, Index >.

reduceAllRows() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Fetch , typename Reduce , typename Keep , typename FetchReal >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::reduceAllRows	(	Fetch &	fetch,
		const Reduce &	reduce,
		Keep &	keep,
		const FetchReal &	identity
	)

Method for performing general reduction on ALL matrix rows.

Template Parameters

Fetch

is a type of lambda function for data fetch declared as

auto fetch = [=] __cuda_callable__ ( IndexType rowIdx, IndexType columnIdx, RealType elementValue ) -> FetchValue

The return type of this lambda can be any non void.

Template Parameters

Reduce

is a type of lambda function for reduction declared as

auto reduce = [=] __cuda_callable__ ( const FetchValue& v1, const FetchValue& v2 ) -> FetchValue { ... };

Template Parameters

Keep	is a type of lambda function for storing results of reduction in each row. It is declared as

auto keep = [=] __cuda_callable__ ( IndexType rowIdx, const RealType& value ) { ... };

Template Parameters

FetchValue

is type returned by the Fetch lambda function.

Parameters

fetch	is an instance of lambda function for data fetch.
reduce	is an instance of lambda function for reduction.
keep	in an instance of lambda function for storing results.
identity	is the identity element for the reduction operation, i.e. element which does not change the result of the reduction.

Example

#include <iostream>
#include <iomanip>
#include <functional>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
 
template< typename Device >
void reduceAllRows()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix {
      {  1,  0,  0,  0,  0 },
      {  1,  2,  0,  0,  0 },
      {  0,  1,  8,  0,  0 },
      {  0,  0,  1,  9,  0 },
      {  0,  0,  0,  0,  1 } };
   auto matrixView = matrix.getView();
 
   /***
    * Find largest element in each row.
    */
   TNL::Containers::Vector< double, Device > rowMax( matrix.getRows() );
 
   /***
    * Prepare vector view and matrix view for lambdas.
    */
   auto rowMaxView = rowMax.getView();
 
   /***
    * Fetch lambda just returns absolute value of matrix elements.
    */
   auto fetch = [=] __cuda_callable__ ( int rowIdx, int columnIdx, const double& value ) -> double {
      return TNL::abs( value );
   };
 
   /***
    * Reduce lambda return maximum of given values.
    */
   auto reduce = [=] __cuda_callable__ ( double& a, const double& b ) -> double {
      return TNL::max( a, b );
   };
 
   /***
    * Keep lambda store the largest value in each row to the vector rowMax.
    */
   auto keep = [=] __cuda_callable__ ( int rowIdx, const double& value ) mutable {
      rowMaxView[ rowIdx ] = value;
   };
 
   /***
    * Compute the largest values in each row.
    */
   matrixView.reduceAllRows( fetch, reduce, keep, std::numeric_limits< double >::lowest() );
 
   std::cout << "Max. elements in rows are: " << rowMax << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "All rows reduction on host:" << std::endl;
   reduceAllRows< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "All rows reduction on CUDA device:" << std::endl;
   reduceAllRows< TNL::Devices::Cuda >();
#endif
}

Output

All rows reduction on host:
Max. elements in rows are: [ 1, 2, 8, 9, 1 ]
All rows reduction on CUDA device:
Max. elements in rows are: [ 1, 2, 8, 9, 1 ]

reduceAllRows() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Fetch , typename Reduce , typename Keep , typename FetchReal >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::reduceAllRows	(	Fetch &	fetch,
		const Reduce &	reduce,
		Keep &	keep,
		const FetchReal &	identity
	)		const

Method for performing general reduction on ALL matrix rows for constant instances.

Template Parameters

Fetch

is a type of lambda function for data fetch declared as

auto fetch = [=] __cuda_callable__ ( IndexType rowIdx, IndexType columnIdx, RealType elementValue ) -> FetchValue { ... };

The return type of this lambda can be any non void.

Template Parameters

Reduce

is a type of lambda function for reduction declared as

auto reduce = [=] __cuda_callable__ ( const FetchValue& v1, const FetchValue& v2 ) -> FetchValue { ... };

Template Parameters

Keep	is a type of lambda function for storing results of reduction in each row. It is declared as

auto keep = [=] __cuda_callable__ ( IndexType rowIdx, const RealType& value ) { ... };

Template Parameters

FetchValue

is type returned by the Fetch lambda function.

Parameters

fetch	is an instance of lambda function for data fetch.
reduce	is an instance of lambda function for reduction.
keep	in an instance of lambda function for storing results.
identity	is the identity element for the reduction operation, i.e. element which does not change the result of the reduction.

Example

#include <iostream>
#include <iomanip>
#include <functional>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
 
template< typename Device >
void reduceAllRows()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix {
      {  1,  0,  0,  0,  0 },
      {  1,  2,  0,  0,  0 },
      {  0,  1,  8,  0,  0 },
      {  0,  0,  1,  9,  0 },
      {  0,  0,  0,  0,  1 } };
   auto matrixView = matrix.getView();
 
   /***
    * Find largest element in each row.
    */
   TNL::Containers::Vector< double, Device > rowMax( matrix.getRows() );
 
   /***
    * Prepare vector view and matrix view for lambdas.
    */
   auto rowMaxView = rowMax.getView();
 
   /***
    * Fetch lambda just returns absolute value of matrix elements.
    */
   auto fetch = [=] __cuda_callable__ ( int rowIdx, int columnIdx, const double& value ) -> double {
      return TNL::abs( value );
   };
 
   /***
    * Reduce lambda return maximum of given values.
    */
   auto reduce = [=] __cuda_callable__ ( double& a, const double& b ) -> double {
      return TNL::max( a, b );
   };
 
   /***
    * Keep lambda store the largest value in each row to the vector rowMax.
    */
   auto keep = [=] __cuda_callable__ ( int rowIdx, const double& value ) mutable {
      rowMaxView[ rowIdx ] = value;
   };
 
   /***
    * Compute the largest values in each row.
    */
   matrixView.reduceAllRows( fetch, reduce, keep, std::numeric_limits< double >::lowest() );
 
   std::cout << "Max. elements in rows are: " << rowMax << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "All rows reduction on host:" << std::endl;
   reduceAllRows< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "All rows reduction on CUDA device:" << std::endl;
   reduceAllRows< TNL::Devices::Cuda >();
#endif
}

Output

All rows reduction on host:
Max. elements in rows are: [ 1, 2, 8, 9, 1 ]
All rows reduction on CUDA device:
Max. elements in rows are: [ 1, 2, 8, 9, 1 ]

reduceRows() [1/2]

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

template<typename Fetch , typename Reduce , typename Keep , typename FetchReal >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::reduceRows	(	IndexType	begin,
		IndexType	end,
		Fetch &	fetch,
		const Reduce &	reduce,
		Keep &	keep,
		const FetchReal &	identity
	)

Method for performing general reduction on matrix rows.

Template Parameters

Fetch

is a type of lambda function for data fetch declared as

auto fetch = [=] __cuda_callable__ ( IndexType rowIdx, IndexType columnIdx, RealType elementValue ) -> FetchValue { ... };

The return type of this lambda can be any non void.

Template Parameters

Reduce

is a type of lambda function for reduction declared as

auto reduce = [=] __cuda_callable__ ( const FetchValue& v1, const FetchValue& v2 ) -> FetchValue { ... };

Template Parameters

Keep	is a type of lambda function for storing results of reduction in each row. It is declared as

auto keep = [=] __cuda_callable__ ( IndexType rowIdx, const RealType& value ) { ... };

Template Parameters

FetchValue

is type returned by the Fetch lambda function.

Parameters

begin	defines beginning of the range [begin,end) of rows to be processed.
end	defines ending of the range [begin,end) of rows to be processed.
fetch	is an instance of lambda function for data fetch.
reduce	is an instance of lambda function for reduction.
keep	in an instance of lambda function for storing results.
identity	is the identity element for the reduction operation, i.e. element which does not change the result of the reduction.

Example

#include <iostream>
#include <iomanip>
#include <functional>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
 
template< typename Device >
void reduceRows()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix {
      {  1,  0,  0,  0,  0 },
      {  1,  2,  0,  0,  0 },
      {  0,  1,  8,  0,  0 },
      {  0,  0,  1,  9,  0 },
      {  0,  0,  0,  0,  1 } };
 
   /***
    * Find largest element in each row.
    */
   TNL::Containers::Vector< double, Device > rowMax( matrix.getRows() );
 
   /***
    * Prepare vector view for lambdas.
    */
   auto rowMaxView = rowMax.getView();
 
   /***
    * Fetch lambda just returns absolute value of matrix elements.
    */
   auto fetch = [=] __cuda_callable__ ( int rowIdx, int columnIdx, const double& value ) -> double {
      return TNL::abs( value );
   };
 
   /***
    * Reduce lambda return maximum of given values.
    */
   auto reduce = [=] __cuda_callable__ ( double& a, const double& b ) -> double {
      return TNL::max( a, b );
   };
 
   /***
    * Keep lambda store the largest value in each row to the vector rowMax.
    */
   auto keep = [=] __cuda_callable__ ( int rowIdx, const double& value ) mutable {
      rowMaxView[ rowIdx ] = value;
   };
 
   /***
    * Compute the largest values in each row.
    */
   matrix.reduceRows( 0, matrix.getRows(), fetch, reduce, keep, std::numeric_limits< double >::lowest() );
 
   std::cout << "Max. elements in rows are: " << rowMax << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Rows reduction on host:" << std::endl;
   reduceRows< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Rows reduction on CUDA device:" << std::endl;
   reduceRows< TNL::Devices::Cuda >();
#endif
}

Output

Rows reduction on host:
Max. elements in rows are: [ 1, 2, 8, 9, 1 ]
Rows reduction on CUDA device:
Max. elements in rows are: [ 1, 2, 8, 9, 1 ]

reduceRows() [2/2]

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

template<typename Fetch , typename Reduce , typename Keep , typename FetchReal >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::reduceRows	(	IndexType	begin,
		IndexType	end,
		Fetch &	fetch,
		const Reduce &	reduce,
		Keep &	keep,
		const FetchReal &	identity
	)		const

Method for performing general reduction on matrix rows for constant instances.

Template Parameters

Fetch

is a type of lambda function for data fetch declared as

auto fetch = [=] __cuda_callable__ ( IndexType rowIdx, IndexType columnIdx, RealType elementValue ) -> FetchValue { ... };

The return type of this lambda can be any non void.

Template Parameters

Reduce

is a type of lambda function for reduction declared as

auto reduce = [=] __cuda_callable__ ( const FetchValue& v1, const FetchValue& v2 ) -> FetchValue { ... };

Template Parameters

Keep	is a type of lambda function for storing results of reduction in each row. It is declared as

auto keep = [=] __cuda_callable__ ( IndexType rowIdx, const RealType& value ) { ... };

Template Parameters

FetchValue

is type returned by the Fetch lambda function.

Parameters

begin	defines beginning of the range [begin,end) of rows to be processed.
end	defines ending of the range [begin,end) of rows to be processed.
fetch	is an instance of lambda function for data fetch.
reduce	is an instance of lambda function for reduction.
keep	in an instance of lambda function for storing results.
identity	is the identity element for the reduction operation, i.e. element which does not change the result of the reduction.

Example

#include <iostream>
#include <iomanip>
#include <functional>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
 
template< typename Device >
void reduceRows()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix {
      {  1,  0,  0,  0,  0 },
      {  1,  2,  0,  0,  0 },
      {  0,  1,  8,  0,  0 },
      {  0,  0,  1,  9,  0 },
      {  0,  0,  0,  0,  1 } };
 
   /***
    * Find largest element in each row.
    */
   TNL::Containers::Vector< double, Device > rowMax( matrix.getRows() );
 
   /***
    * Prepare vector view for lambdas.
    */
   auto rowMaxView = rowMax.getView();
 
   /***
    * Fetch lambda just returns absolute value of matrix elements.
    */
   auto fetch = [=] __cuda_callable__ ( int rowIdx, int columnIdx, const double& value ) -> double {
      return TNL::abs( value );
   };
 
   /***
    * Reduce lambda return maximum of given values.
    */
   auto reduce = [=] __cuda_callable__ ( double& a, const double& b ) -> double {
      return TNL::max( a, b );
   };
 
   /***
    * Keep lambda store the largest value in each row to the vector rowMax.
    */
   auto keep = [=] __cuda_callable__ ( int rowIdx, const double& value ) mutable {
      rowMaxView[ rowIdx ] = value;
   };
 
   /***
    * Compute the largest values in each row.
    */
   matrix.reduceRows( 0, matrix.getRows(), fetch, reduce, keep, std::numeric_limits< double >::lowest() );
 
   std::cout << "Max. elements in rows are: " << rowMax << std::endl;
}
 
int main( int argc, char* argv[] )
{
   std::cout << "Rows reduction on host:" << std::endl;
   reduceRows< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Rows reduction on CUDA device:" << std::endl;
   reduceRows< TNL::Devices::Cuda >();
#endif
}

Output

Rows reduction on host:
Max. elements in rows are: [ 1, 2, 8, 9, 1 ]
Rows reduction on CUDA device:
Max. elements in rows are: [ 1, 2, 8, 9, 1 ]

save() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::save

(

const String &

fileName

)

const

Method for saving the matrix view to the file with given filename.

The ouput file can be loaded by DenseMatrix.

Parameters

fileName

is name of the file.

save() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::save ( File &  file ) const

overridevirtual

Method for saving the matrix view to a file.

The ouput file can be loaded by DenseMatrix.

Parameters

file	is the file where the matrix will be saved.

Reimplemented from TNL::Matrices::MatrixView< Real, Device, Index >.

sequentialForAllRows() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::sequentialForAllRows

(

Function &&

function

)

This method calls sequentialForRows for all matrix rows.

See DenseMatrixView::sequentialForAllRows.

Template Parameters

Function

is a type of lambda function that will operate on matrix elements.

Parameters

function

is an instance of the lambda function to be called in each row.

sequentialForAllRows() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::sequentialForAllRows

(

Function &&

function

)

const

This method calls sequentialForRows for all matrix rows (for constant instances).

See DenseMatrixView::sequentialForRows.

Template Parameters

Function

is a type of lambda function that will operate on matrix elements.

Parameters

function

is an instance of the lambda function to be called in each row.

sequentialForRows() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::sequentialForRows	(	IndexType	begin,
		IndexType	end,
		Function &&	function
	)

Method for sequential iteration over all matrix rows for non-constant instances.

Template Parameters

Function

is type of lambda function that will operate on matrix elements. It is should have form like

auto function = [] __cuda_callable__ ( RowView& row ) { ... };

RowView represents matrix row - see TNL::Matrices::DenseMatrixView::RowView.

Parameters

begin	defines beginning of the range [begin,end) of rows to be processed.
end	defines ending of the range [begin,end) of rows to be processed.
function	is an instance of the lambda function to be called in each row.

sequentialForRows() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename Function >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::sequentialForRows	(	IndexType	begin,
		IndexType	end,
		Function &&	function
	)		const

Method for sequential iteration over all matrix rows for constant instances.

Template Parameters

Function

is type of lambda function that will operate on matrix elements. It is should have form like

auto function = [] __cuda_callable__ ( RowView& row ) { ... };

RowView represents matrix row - see TNL::Matrices::DenseMatrixView::RowView.

Parameters

begin	defines beginning of the range [begin,end) of rows to be processed.
end	defines ending of the range [begin,end) of rows to be processed.
function	is an instance of the lambda function to be called in each row.

setElement()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

__cuda_callable__ void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::setElement	(	IndexType	row,
		IndexType	column,
		const RealType &	value
	)

Sets element at given row and column to given value.

This method can be called from the host system (CPU) no matter where the matrix is allocated. If the matrix is allocated on GPU this method can be called even from device kernels. If the matrix is allocated in GPU device this method is called from CPU, it transfers values of each matrix element separately and so the performance is very low. For higher performance see. DenseMatrix::getRow or DenseMatrix::forElements and DenseMatrix::forAllElements.

Parameters

row	is row index of the element.
column	is columns index of the element.
value	is the value the element will be set to.

Example

#include <iostream>
#include <TNL/Algorithms/parallelFor.h>
#include <TNL/Containers/StaticArray.h>
#include <TNL/Matrices/DenseMatrix.h>
#include <TNL/Devices/Host.h>
 
template< typename Device >
void
setElements()
{
   TNL::Matrices::DenseMatrix< double, Device > matrix( 5, 5 );
   auto matrixView = matrix.getView();
   for( int i = 0; i < 5; i++ )
      matrixView.setElement( i, i, i );
 
   std::cout << "Matrix set from the host:" << std::endl;
   std::cout << matrix << std::endl;
 
   auto f = [ = ] __cuda_callable__( const TNL::Containers::StaticArray< 2, int >& i ) mutable
   {
      matrixView.addElement( i[ 0 ], i[ 1 ], 5.0 );
   };
   TNL::Containers::StaticArray< 2, int > begin = { 0, 0 };
   TNL::Containers::StaticArray< 2, int > end = { 5, 5 };
   TNL::Algorithms::parallelFor< Device >( begin, end, f );
 
   std::cout << "Matrix set from its native device:" << std::endl;
   std::cout << matrix << std::endl;
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Set elements on host:" << std::endl;
   setElements< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Set elements on CUDA device:" << std::endl;
   setElements< TNL::Devices::Cuda >();
#endif
}

Output

Set elements on host:
Matrix set from the host:
Row: 0 ->     0:0       1:0       2:0       3:0       4:0   
Row: 1 ->     0:0       1:1       2:0       3:0       4:0   
Row: 2 ->     0:0       1:0       2:2       3:0       4:0   
Row: 3 ->     0:0       1:0       2:0       3:3       4:0   
Row: 4 ->     0:0       1:0       2:0       3:0       4:4   
Matrix set from its native device:
Row: 0 ->     0:5       1:5       2:5       3:5       4:5   
Row: 1 ->     0:5       1:6       2:5       3:5       4:5   
Row: 2 ->     0:5       1:5       2:7       3:5       4:5   
Row: 3 ->     0:5       1:5       2:5       3:8       4:5   
Row: 4 ->     0:5       1:5       2:5       3:5       4:9   
Set elements on CUDA device:
Matrix set from the host:
Row: 0 ->     0:0       1:0       2:0       3:0       4:0   
Row: 1 ->     0:0       1:1       2:0       3:0       4:0   
Row: 2 ->     0:0       1:0       2:2       3:0       4:0   
Row: 3 ->     0:0       1:0       2:0       3:3       4:0   
Row: 4 ->     0:0       1:0       2:0       3:0       4:4   
Matrix set from its native device:
Row: 0 ->     0:5       1:5       2:5       3:5       4:5   
Row: 1 ->     0:5       1:6       2:5       3:5       4:5   
Row: 2 ->     0:5       1:5       2:7       3:5       4:5   
Row: 3 ->     0:5       1:5       2:5       3:8       4:5   
Row: 4 ->     0:5       1:5       2:5       3:5       4:9   

setValue()

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::setValue

(

const RealType &

v

)

Sets all matrix elements to value v.

Parameters

v	is value all matrix elements will be set to.

vectorProduct()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>

template<typename InVector , typename OutVector >

void TNL::Matrices::DenseMatrixView< Real, Device, Index, Organization >::vectorProduct	(	const InVector &	inVector,
		OutVector &	outVector,
		const RealType &	matrixMultiplicator = 1.0,
		const RealType &	outVectorMultiplicator = 0.0,
		IndexType	begin = 0,
		IndexType	end = 0
	)		const

Computes product of matrix and vector.

More precisely, it computes:

outVector = matrixMultiplicator * ( *this ) * inVector + outVectorMultiplicator * outVector

Template Parameters

InVector	is type of input vector. It can be TNL::Containers::Vector, TNL::Containers::VectorView, TNL::Containers::Array, TNL::Containers::ArrayView, or similar container.
OutVector	is type of output vector. It can be TNL::Containers::Vector, TNL::Containers::VectorView, TNL::Containers::Array, TNL::Containers::ArrayView, or similar container.

Parameters

inVector	is input vector.
outVector	is output vector.
matrixMultiplicator	is a factor by which the matrix is multiplied. It is one by default.
outVectorMultiplicator	is a factor by which the outVector is multiplied before added to the result of matrix-vector product. It is zero by default.
begin	is the beginning of the rows range for which the vector product is computed. It is zero by default.
end	is the end of the rows range for which the vector product is computed. It is number if the matrix rows by default.

Note that the ouput vector dimension must be the same as the number of matrix rows no matter how we set begin and end parameters. These parameters just say that some matrix rows and the output vector elements are omitted.

---

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

• src/TNL/Matrices/DenseMatrixView.h
• src/TNL/Matrices/DenseMatrixView.hpp