Template Numerical Library version main:e6bb26f
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization > Class Template Reference

Implementation of sparse tridiagonal matrix. More...

#include <TNL/Matrices/TridiagonalMatrixView.h>

Inheritance diagram for TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >:
Inheritance graph
[legend]
Collaboration diagram for TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >:
Collaboration graph
[legend]

Public Types

using BaseType = MatrixView< Real, Device, Index >
 
using ConstRowView = typename RowView::ConstRowView
 Type for accessing constant matrix rows.
 
using ConstViewType = TridiagonalMatrixView< typename std::add_const< Real >::type, Device, Index, Organization >
 Matrix view type for constant instances.
 
using DeviceType = Device
 The device where the matrix is allocated.
 
using IndexerType = details::TridiagonalMatrixIndexer< Index, Organization >
 
using IndexType = Index
 The type used for matrix elements indexing.
 
using RealType = Real
 The type of matrix elements.
 
using RowView = TridiagonalMatrixRowView< ValuesViewType, IndexerType >
 Type for accessing matrix rows.
 
template<typename _Real = Real, typename _Device = Device, typename _Index = Index, ElementsOrganization Organization_ = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>
using Self = TridiagonalMatrixView< _Real, _Device, _Index, Organization_ >
 Helper type for getting self type or its modifications.
 
using ValuesViewType = typename BaseType::ValuesView
 
using ViewType = TridiagonalMatrixView< Real, Device, Index, Organization >
 
- Public Types inherited from TNL::Matrices::MatrixView< double, Devices::Host, int >
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< double >, Devices::Host, int >
 Type of base matrix view for constant instances.
 
using DeviceType = Devices::Host
 The device where the matrix is allocated.
 
using IndexType = int
 The type used for matrix elements indexing.
 
using RealType = double
 The type of matrix elements.
 
using RowsCapacitiesType = Containers::Vector< int, Devices::Host, int >
 
using RowsCapacitiesTypeView = Containers::VectorView< int, Devices::Host, int >
 
using ValuesView = Containers::VectorView< double, Devices::Host, int >
 Type of vector view holding values of matrix elements.
 
using ViewType = MatrixView< double, Devices::Host, int >
 Type of base matrix view.
 

Public Member Functions

__cuda_callable__ TridiagonalMatrixView ()
 Constructor with no parameters.
 
__cuda_callable__ TridiagonalMatrixView (const TridiagonalMatrixView &view)=default
 Copy constructor. More...
 
__cuda_callable__ TridiagonalMatrixView (const ValuesViewType &values, const IndexerType &indexer)
 Constructor with all necessary data and views. More...
 
__cuda_callable__ TridiagonalMatrixView (TridiagonalMatrixView &&view) noexcept=default
 Move constructor. 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 Real_ , typename Device_ , typename Index_ , ElementsOrganization Organization_>
void addMatrix (const TridiagonalMatrixView< Real_, Device_, Index_, Organization_ > &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 (for constant instances). 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...
 
template<typename Vector >
void getCompressedRowLengths (Vector &rowLengths) const
 Computes number of non-zeros in each row. More...
 
ConstViewType getConstView () const
 Returns a non-modifiable view of the tridiagonal matrix. More...
 
__cuda_callable__ RealType getElement (IndexType row, IndexType column) const
 Returns value of matrix element at position given by its row and column index. More...
 
__cuda_callable__ IndexerTypegetIndexer ()
 This method returns matrix elements indexer used by this matrix. More...
 
__cuda_callable__ const IndexerTypegetIndexer () const
 This method returns matrix elements indexer used by this matrix. More...
 
IndexType getNonzeroElementsCount () const override
 Returns number of non-zero matrix elements. More...
 
__cuda_callable__ IndexType getPaddingIndex () const
 Returns padding index denoting padding zero elements. More...
 
__cuda_callable__ RowView getRow (const IndexType &rowIdx)
 Non-constant getter of simple structure for accessing given matrix row. More...
 
__cuda_callable__ const ConstRowView getRow (const 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...
 
template<typename Real2 , typename Index2 >
void getTransposition (const TridiagonalMatrixView< Real2, Device, Index2 > &matrix, const RealType &matrixMultiplicator=1.0)
 
ViewType getView ()
 Returns a modifiable view of the tridiagonal matrix. More...
 
template<typename Real_ , typename Device_ , typename Index_ , ElementsOrganization Organization_>
bool operator!= (const TridiagonalMatrixView< Real_, Device_, Index_, Organization_ > &matrix) const
 Comparison operator with another multidiagonal matrix. More...
 
TridiagonalMatrixViewoperator= (const TridiagonalMatrixView &view)
 Assignment of exactly the same matrix type. More...
 
template<typename Real_ , typename Device_ , typename Index_ , ElementsOrganization Organization_>
bool operator== (const TridiagonalMatrixView< Real_, Device_, Index_, Organization_ > &matrix) const
 Comparison operator with another tridiagonal matrix. 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, 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, 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, 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, Reduce &reduce, Keep &keep, const FetchReal &identity) const
 Method for performing general reduction on matrix rows for constant instances. More...
 
void save (const String &fileName) const
 Method for saving the matrix to the file with given filename. More...
 
void save (File &file) const override
 Method for saving the matrix 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 &value)
 Set all matrix elements to given value. More...
 
template<typename InVector , typename OutVector >
void vectorProduct (const InVector &inVector, OutVector &outVector, RealType matrixMultiplicator=1.0, 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< double, Devices::Host, int >
__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...
 
__cuda_callable__ ValuesViewgetValues ()
 Returns a reference to a vector with the matrix elements values. More...
 
__cuda_callable__ const ValuesViewgetValues () const
 Returns a constant reference to a vector with the matrix elements values. More...
 
bool operator!= (const Matrix &matrix) const
 Comparison operator with another arbitrary matrix view type. More...
 
bool operator!= (const MatrixT &matrix) const
 
__cuda_callable__ MatrixViewoperator= (const MatrixView &view)
 Shallow copy of the matrix view. More...
 
bool operator== (const Matrix &matrix) const
 Comparison operator with another arbitrary matrix view type. More...
 
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 (File &file) const override
 Method for saving the matrix view to a file. More...
 
- Public Member Functions inherited from TNL::Object
virtual ~Object ()=default
 Destructor. More...
 
virtual std::string getSerializationTypeVirtual () const
 
void load (const String &fileName)
 Method for restoring the object from a file. More...
 
virtual void load (File &file)
 Method for restoring the object from a file. More...
 
void save (const String &fileName) const
 Method for saving the object to a file as a binary data. More...
 
virtual void save (File &file) const
 Method for saving the object to a file as a binary data. More...
 

Static Public Member Functions

static std::string getSerializationType ()
 Returns string with serialization type. More...
 
- Static Public Member Functions inherited from TNL::Object
static std::string getSerializationType ()
 Static serialization type getter. More...
 

Protected Member Functions

__cuda_callable__ IndexType getElementIndex (IndexType row, IndexType localIdx) const
 

Protected Attributes

IndexerType indexer
 
- Protected Attributes inherited from TNL::Matrices::MatrixView< double, Devices::Host, int >
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::TridiagonalMatrixView< Real, Device, Index, Organization >

Implementation of sparse tridiagonal matrix.

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

See TridiagonalMatrix for more details.

Template Parameters
Realis a type of matrix elements.
Deviceis a device where the matrix is allocated.
Indexis a type for indexing of the matrix elements.
Organizationtells the ordering of matrix elements. It is either RowMajorOrder or ColumnMajorOrder.

Constructor & Destructor Documentation

◆ TridiagonalMatrixView() [1/3]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::TridiagonalMatrixView ( const ValuesViewType &  values,
const IndexerType indexer 
)

Constructor with all necessary data and views.

Parameters
valuesis a vector view with matrix elements values
indexeris an indexer of matrix elements

◆ TridiagonalMatrixView() [2/3]

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>
__cuda_callable__ TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::TridiagonalMatrixView ( const TridiagonalMatrixView< Real, Device, Index, Organization > &  view)
default

Copy constructor.

Parameters
viewis an input tridiagonal matrix view.

◆ TridiagonalMatrixView() [3/3]

template<typename Real = double, typename Device = Devices::Host, typename Index = int, ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization()>
__cuda_callable__ TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::TridiagonalMatrixView ( TridiagonalMatrixView< Real, Device, Index, Organization > &&  view)
defaultnoexcept

Move constructor.

Parameters
viewis an input tridiagonal matrix view.

Member Function Documentation

◆ addElement()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
__cuda_callable__ void TNL::Matrices::TridiagonalMatrixView< 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. TridiagonalMatrix::getRow or TridiagonalMatrix::forElements and TridiagonalMatrix::forAllElements. The call may fail if the matrix row capacity is exhausted.

Parameters
rowis row index of the element.
columnis columns index of the element.
valueis the value the element will be set to.
thisElementMultiplicatoris multiplicator the original matrix element value is multiplied by before addition of given value.
Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
template< typename Device >
void addElements()
{
const int matrixSize( 5 );
matrixSize, // number of rows
matrixSize // number of columns
);
auto view = matrix.getView();
for( int i = 0; i < matrixSize; i++ )
view.setElement( i, i, i );
std::cout << "Initial matrix is: " << std::endl << matrix << std::endl;
for( int i = 0; i < matrixSize; i++ )
{
if( i > 0 )
view.addElement( i, i - 1, 1.0, 5.0 );
view.addElement( i, i, 1.0, 5.0 );
if( i < matrixSize - 1 )
view.addElement( i, i + 1, 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 HAVE_CUDA
std::cout << "Add elements on CUDA device:" << std::endl;
addElements< TNL::Devices::Cuda >();
#endif
}
Implementation of sparse tridiagonal matrix.
Definition: TridiagonalMatrix.h:63
T endl(T... args)
Output
Add elements on host:
Initial matrix is:
Row: 0 ->
Row: 1 -> 1:1
Row: 2 -> 2:2
Row: 3 -> 3:3
Row: 4 -> 4:4
Matrix after addition is:
Row: 0 -> 0:1 1:1
Row: 1 -> 0:1 1:6 2:1
Row: 2 -> 1:1 2:11 3:1
Row: 3 -> 2:1 3:16 4:1
Row: 4 -> 3:1 4:21
Add elements on CUDA device:
Initial matrix is:
Row: 0 ->
Row: 1 -> 1:1
Row: 2 -> 2:2
Row: 3 -> 3:3
Row: 4 -> 4:4
Matrix after addition is:
Row: 0 -> 0:1 1:1
Row: 1 -> 0:1 1:6 2:1
Row: 2 -> 1:1 2:11 3:1
Row: 3 -> 2:1 3:16 4:1
Row: 4 -> 3:1 4:21

◆ forAllElements() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Function >
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::forAllElements ( Function &  function)

This method calls forElements for all matrix rows.

See TridiagonalMatrix::forElements.

Template Parameters
Functionis a type of lambda function that will operate on matrix elements.
Parameters
functionis an instance of the lambda function to be called in each row.
Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void forAllElementsExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 1 3 . . . \ -> { 0, 1, 3 }
* | 2 1 3 . . | -> { 2, 1, 3 }
* | . 2 1 3 . | -> { 2, 1, 3 }
* | . . 2 1 3 | -> { 2, 1, 3 }
* \ . . . 2 1 / 0 -> { 2, 1, 0 }
*/
5, // number of matrix rows
5 ); // number of matrix columns
auto view = matrix.getView();
auto f = [=] __cuda_callable__ ( int rowIdx, int localIdx, int columnIdx, double& value ) {
/***
* 'forElements' method iterates only over matrix elements lying on given subdiagonals
* and so we do not need to check anything. The element value can be expressed
* by the 'localIdx' variable, see the following figure:
*
* 0 1 2 <- localIdx values
* -------
* 0 / 1 3 . . . \ -> { 0, 1, 3 }
* | 2 1 3 . . | -> { 2, 1, 3 }
* | . 2 1 3 . | -> { 2, 1, 3 }
* | . . 2 1 3 | -> { 2, 1, 3 }
* \ . . . 2 1 / 0 -> { 2, 1, 0 }
*
*/
value = 3 - localIdx;
};
view.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 HAVE_CUDA
std::cout << "Creating matrix on CUDA device: " << std::endl;
forAllElementsExample< TNL::Devices::Cuda >();
#endif
}
#define __cuda_callable__
Definition: CudaCallable.h:22
Output
Creating matrix on host:
Row: 0 -> 0:2 1:1
Row: 1 -> 0:3 1:2 2:1
Row: 2 -> 1:3 2:2 3:1
Row: 3 -> 2:3 3:2 4:1
Row: 4 -> 3:3 4:2
Creating matrix on CUDA device:
Row: 0 -> 0:2 1:1
Row: 1 -> 0:3 1:2 2:1
Row: 2 -> 1:3 2:2 3:1
Row: 3 -> 2:3 3:2 4:1
Row: 4 -> 3:3 4:2

◆ forAllElements() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Function >
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::forAllElements ( Function &  function) const

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

See TridiagonalMatrix::forElements.

Template Parameters
Functionis a type of lambda function that will operate on matrix elements.
Parameters
functionis an instance of the lambda function to be called in each row.
Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void forAllElementsExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 1 3 . . . \ -> { 0, 1, 3 }
* | 2 1 3 . . | -> { 2, 1, 3 }
* | . 2 1 3 . | -> { 2, 1, 3 }
* | . . 2 1 3 | -> { 2, 1, 3 }
* \ . . . 2 1 / 0 -> { 2, 1, 0 }
*/
5, // number of matrix rows
5 ); // number of matrix columns
auto view = matrix.getView();
auto f = [=] __cuda_callable__ ( int rowIdx, int localIdx, int columnIdx, double& value ) {
/***
* 'forElements' method iterates only over matrix elements lying on given subdiagonals
* and so we do not need to check anything. The element value can be expressed
* by the 'localIdx' variable, see the following figure:
*
* 0 1 2 <- localIdx values
* -------
* 0 / 1 3 . . . \ -> { 0, 1, 3 }
* | 2 1 3 . . | -> { 2, 1, 3 }
* | . 2 1 3 . | -> { 2, 1, 3 }
* | . . 2 1 3 | -> { 2, 1, 3 }
* \ . . . 2 1 / 0 -> { 2, 1, 0 }
*
*/
value = 3 - localIdx;
};
view.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 HAVE_CUDA
std::cout << "Creating matrix on CUDA device: " << std::endl;
forAllElementsExample< TNL::Devices::Cuda >();
#endif
}
Output
Creating matrix on host:
Row: 0 -> 0:2 1:1
Row: 1 -> 0:3 1:2 2:1
Row: 2 -> 1:3 2:2 3:1
Row: 3 -> 2:3 3:2 4:1
Row: 4 -> 3:3 4:2
Creating matrix on CUDA device:
Row: 0 -> 0:2 1:1
Row: 1 -> 0:3 1:2 2:1
Row: 2 -> 1:3 2:2 3:1
Row: 3 -> 2:3 3:2 4:1
Row: 4 -> 3:3 4:2

◆ forAllRows() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Function >
void TNL::Matrices::TridiagonalMatrixView< 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 TridiagonalMatrixView::forAllElements where more than one thread can be mapped to each row.

Template Parameters
Functionis type of the lambda function.
Parameters
functionis an instance of the lambda function to be called for each row.
auto function = [] __cuda_callable__ ( RowView& row ) mutable { ... };
TridiagonalMatrixRowView< ValuesViewType, IndexerType > RowView
Type for accessing matrix rows.
Definition: TridiagonalMatrixView.h:71

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

Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void forRowsExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 2 . . . . \ -> { 0, 0, 1 }
* | -1 2 -1 . . | -> { 0, 2, 1 }
* | . -1 2 -1. . | -> { 3, 2, 1 }
* | . . -1 2 -1 | -> { 3, 2, 1 }
* \ . . . . 2 / -> { 3, 2, 1 }
*
* The diagonals offsets are { -1, 0, 1 }.
*/
const int size = 5;
MatrixType matrix( size, size );
auto f = [=] __cuda_callable__ ( typename MatrixType::RowView& row ) {
const int& rowIdx = row.getRowIndex();
if( rowIdx > 0 )
row.setElement( 0, -1.0 ); // elements below the diagonal
row.setElement( 1, 2.0 ); // elements on the diagonal
if( rowIdx < size - 1 ) // elements above the diagonal
row.setElement( 2, -1.0 );
};
matrix.forAllRows( f );
std::cout << matrix << std::endl;
}
int main( int argc, char* argv[] )
{
std::cout << "Creating matrix on host: " << std::endl;
forRowsExample< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Creating matrix on CUDA device: " << std::endl;
forRowsExample< TNL::Devices::Cuda >();
#endif
}
Output
Creating matrix on host:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2
Creating matrix on CUDA device:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2

◆ forAllRows() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Function >
void TNL::Matrices::TridiagonalMatrixView< 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 TridiagonalMatrixView::forAllElements where more than one thread can be mapped to each row.

Template Parameters
Functionis type of the lambda function.
Parameters
functionis 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::TridiagonalMatrixView::RowView.

Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void forRowsExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 2 . . . . \ -> { 0, 0, 1 }
* | -1 2 -1 . . | -> { 0, 2, 1 }
* | . -1 2 -1. . | -> { 3, 2, 1 }
* | . . -1 2 -1 | -> { 3, 2, 1 }
* \ . . . . 2 / -> { 3, 2, 1 }
*
* The diagonals offsets are { -1, 0, 1 }.
*/
const int size = 5;
MatrixType matrix( size, size );
auto f = [=] __cuda_callable__ ( typename MatrixType::RowView& row ) {
const int& rowIdx = row.getRowIndex();
if( rowIdx > 0 )
row.setElement( 0, -1.0 ); // elements below the diagonal
row.setElement( 1, 2.0 ); // elements on the diagonal
if( rowIdx < size - 1 ) // elements above the diagonal
row.setElement( 2, -1.0 );
};
matrix.forAllRows( f );
std::cout << matrix << std::endl;
}
int main( int argc, char* argv[] )
{
std::cout << "Creating matrix on host: " << std::endl;
forRowsExample< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Creating matrix on CUDA device: " << std::endl;
forRowsExample< TNL::Devices::Cuda >();
#endif
}
Output
Creating matrix on host:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2
Creating matrix on CUDA device:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2

◆ forElements() [1/2]

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

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

Template Parameters
Functionis type of lambda function that will operate on matrix elements. It is should have form like
auto function = [=] __cuda_callable__ ( IndexType rowIdx, IndexType localIdx, IndexType columnIdx, const RealType& value )
{ ... };
Real RealType
The type of matrix elements.
Definition: TridiagonalMatrixView.h:47
Index IndexType
The type used for matrix elements indexing.
Definition: TridiagonalMatrixView.h:57

The localIdx parameter is a rank of the non-zero element in given row.

Parameters
begindefines beginning of the range [ begin, end ) of rows to be processed.
enddefines ending of the range [ begin, end ) of rows to be processed.
functionis an instance of the lambda function to be called in each row.
Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void forRowsExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 2 . . . . \ -> { 0, 0, 1 }
* | -1 2 -1 . . | -> { 0, 2, 1 }
* | . -1 2 -1. . | -> { 3, 2, 1 }
* | . . -1 2 -1 | -> { 3, 2, 1 }
* \ . . . . 2 / -> { 3, 2, 1 }
*
* The diagonals offsets are { -1, 0, 1 }.
*/
const int size = 5;
MatrixType matrix( size, size );
auto f = [=] __cuda_callable__ ( typename MatrixType::RowView& row ) {
const int& rowIdx = row.getRowIndex();
if( rowIdx > 0 )
row.setElement( 0, -1.0 ); // elements below the diagonal
row.setElement( 1, 2.0 ); // elements on the diagonal
if( rowIdx < size - 1 ) // elements above the diagonal
row.setElement( 2, -1.0 );
};
matrix.forAllRows( f );
std::cout << matrix << std::endl;
}
int main( int argc, char* argv[] )
{
std::cout << "Creating matrix on host: " << std::endl;
forRowsExample< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Creating matrix on CUDA device: " << std::endl;
forRowsExample< TNL::Devices::Cuda >();
#endif
}
Output
Creating matrix on host:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2
Creating matrix on CUDA device:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2

◆ forElements() [2/2]

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

Method for iteration over all matrix rows for constant instances.

Template Parameters
Functionis type of lambda function that will operate on matrix elements. It is should have form like
auto function = [=] __cuda_callable__ ( IndexType rowIdx, IndexType localIdx, IndexType columnIdx, const RealType& value )
{ ... };

The localIdx parameter is a rank of the non-zero element in given row.

Parameters
begindefines beginning of the range [ begin, end ) of rows to be processed.
enddefines ending of the range [ begin,end ) of rows to be processed.
functionis an instance of the lambda function to be called in each row.
Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void forRowsExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 2 . . . . \ -> { 0, 0, 1 }
* | -1 2 -1 . . | -> { 0, 2, 1 }
* | . -1 2 -1. . | -> { 3, 2, 1 }
* | . . -1 2 -1 | -> { 3, 2, 1 }
* \ . . . . 2 / -> { 3, 2, 1 }
*
* The diagonals offsets are { -1, 0, 1 }.
*/
const int size = 5;
MatrixType matrix( size, size );
auto f = [=] __cuda_callable__ ( typename MatrixType::RowView& row ) {
const int& rowIdx = row.getRowIndex();
if( rowIdx > 0 )
row.setElement( 0, -1.0 ); // elements below the diagonal
row.setElement( 1, 2.0 ); // elements on the diagonal
if( rowIdx < size - 1 ) // elements above the diagonal
row.setElement( 2, -1.0 );
};
matrix.forAllRows( f );
std::cout << matrix << std::endl;
}
int main( int argc, char* argv[] )
{
std::cout << "Creating matrix on host: " << std::endl;
forRowsExample< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Creating matrix on CUDA device: " << std::endl;
forRowsExample< TNL::Devices::Cuda >();
#endif
}
Output
Creating matrix on host:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2
Creating matrix on CUDA device:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2

◆ forRows() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Function >
void TNL::Matrices::TridiagonalMatrixView< 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 TridiagonalMatrixView::forElements where more than one thread can be mapped to each row.

Template Parameters
Functionis type of the lambda function.
Parameters
begindefines beginning of the range [ begin,end ) of rows to be processed.
enddefines ending of the range [ begin, end ) of rows to be processed.
functionis 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::TridiagonalMatrixView::RowView.

Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void forRowsExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 2 . . . . \ -> { 0, 0, 1 }
* | -1 2 -1 . . | -> { 0, 2, 1 }
* | . -1 2 -1. . | -> { 3, 2, 1 }
* | . . -1 2 -1 | -> { 3, 2, 1 }
* \ . . . . 2 / -> { 3, 2, 1 }
*
* The diagonals offsets are { -1, 0, 1 }.
*/
const int size = 5;
MatrixType matrix( size, size );
auto f = [=] __cuda_callable__ ( typename MatrixType::RowView& row ) {
const int& rowIdx = row.getRowIndex();
if( rowIdx > 0 )
row.setElement( 0, -1.0 ); // elements below the diagonal
row.setElement( 1, 2.0 ); // elements on the diagonal
if( rowIdx < size - 1 ) // elements above the diagonal
row.setElement( 2, -1.0 );
};
matrix.forAllRows( f );
std::cout << matrix << std::endl;
}
int main( int argc, char* argv[] )
{
std::cout << "Creating matrix on host: " << std::endl;
forRowsExample< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Creating matrix on CUDA device: " << std::endl;
forRowsExample< TNL::Devices::Cuda >();
#endif
}
Output
Creating matrix on host:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2
Creating matrix on CUDA device:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2

◆ forRows() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Function >
void TNL::Matrices::TridiagonalMatrixView< 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 TridiagonalMatrixView::forElements where more than one thread can be mapped to each row.

Template Parameters
Functionis type of the lambda function.
Parameters
begindefines beginning of the range [ begin,end ) of rows to be processed.
enddefines ending of the range [ begin, end ) of rows to be processed.
functionis 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::TridiagonalMatrixView::RowView.

Example
#include <iostream>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void forRowsExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 2 . . . . \ -> { 0, 0, 1 }
* | -1 2 -1 . . | -> { 0, 2, 1 }
* | . -1 2 -1. . | -> { 3, 2, 1 }
* | . . -1 2 -1 | -> { 3, 2, 1 }
* \ . . . . 2 / -> { 3, 2, 1 }
*
* The diagonals offsets are { -1, 0, 1 }.
*/
const int size = 5;
MatrixType matrix( size, size );
auto f = [=] __cuda_callable__ ( typename MatrixType::RowView& row ) {
const int& rowIdx = row.getRowIndex();
if( rowIdx > 0 )
row.setElement( 0, -1.0 ); // elements below the diagonal
row.setElement( 1, 2.0 ); // elements on the diagonal
if( rowIdx < size - 1 ) // elements above the diagonal
row.setElement( 2, -1.0 );
};
matrix.forAllRows( f );
std::cout << matrix << std::endl;
}
int main( int argc, char* argv[] )
{
std::cout << "Creating matrix on host: " << std::endl;
forRowsExample< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Creating matrix on CUDA device: " << std::endl;
forRowsExample< TNL::Devices::Cuda >();
#endif
}
Output
Creating matrix on host:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2
Creating matrix on CUDA device:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2

◆ getCompressedRowLengths()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Vector >
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getCompressedRowLengths ( Vector &  rowLengths) const

Computes number of non-zeros in each row.

Parameters
rowLengthsis a vector into which the number of non-zeros in each row will be stored.
Example
#include <iostream>
#include <TNL/Algorithms/ParallelFor.h>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void laplaceOperatorMatrix()
{
const int gridSize( 6 );
const int matrixSize = gridSize;
matrixSize, // number of rows
matrixSize // number of columns
);
matrix.setElements( {
{ 0.0, 1.0 },
{ -1.0, 2.0, -1.0 },
{ -1.0, 2.0, -1.0 },
{ -1.0, 2.0, -1.0 },
{ -1.0, 2.0, -1.0 },
{ 0.0, 1.0 }
} );
auto view = matrix.getView();
view.getCompressedRowLengths( rowLengths );
std::cout << "Laplace operator matrix: " << std::endl << matrix << std::endl;
std::cout << "Compressed row lengths: " << rowLengths << std::endl;
}
int main( int argc, char* argv[] )
{
std::cout << "Creating Laplace operator matrix on CPU ... " << std::endl;
laplaceOperatorMatrix< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Creating Laplace operator matrix on CUDA GPU ... " << std::endl;
laplaceOperatorMatrix< TNL::Devices::Cuda >();
#endif
}
Vector extends Array with algebraic operations.
Definition: Vector.h:40
Output
Creating Laplace operator matrix on CPU ...
Laplace operator matrix:
Row: 0 -> 0:1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2 5:-1
Row: 5 -> 5:1
Compressed row lengths: [ 1, 3, 3, 3, 3, 1 ]
Creating Laplace operator matrix on CUDA GPU ...
Laplace operator matrix:
Row: 0 -> 0:1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2 5:-1
Row: 5 -> 5:1
Compressed row lengths: [ 1, 3, 3, 3, 3, 1 ]

◆ getConstView()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
auto TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getConstView

Returns a non-modifiable view of the tridiagonal matrix.

Returns
tridiagonal matrix view.

◆ getElement()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
__cuda_callable__ Real TNL::Matrices::TridiagonalMatrixView< 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. TridiagonalMatrix::getRow or TridiagonalMatrix::forElements and TridiagonalMatrix::forAllElements.

Parameters
rowis a row index of the matrix element.
columni a column index of the matrix element.
Returns
value of given matrix element.
Example
#include <iostream>
#include <iomanip>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
template< typename Device >
void getElements()
{
const int matrixSize( 5 );
matrixSize, // number of matrix columns
{ // matrix elements definition
{ 0.0, 2.0, -1.0 },
{ -1.0, 2.0, -1.0 },
{ -1.0, 2.0, -1.0 },
{ -1.0, 2.0, -1.0 },
{ -1.0, 2.0, 0.0 }
} );
auto view = matrix.getView();
for( int i = 0; i < matrixSize; i++ )
{
for( int j = 0; j < matrixSize; j++ )
std::cout << std::setw( 5 ) << view.getElement( i, j );
}
}
int main( int argc, char* argv[] )
{
std::cout << "Get elements on host:" << std::endl;
getElements< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Get elements on CUDA device:" << std::endl;
getElements< TNL::Devices::Cuda >();
#endif
}
ViewType getView() const
Returns a modifiable view of the tridiagonal matrix.
Definition: TridiagonalMatrix.hpp:39
RealType getElement(IndexType row, IndexType column) const
Returns value of matrix element at position given by its row and column index.
Definition: TridiagonalMatrix.hpp:224
T setw(T... args)
Output
Get elements on host:
2 -1 0 0 0
-1 2 -1 0 0
0 -1 2 -1 0
0 0 -1 2 -1
0 0 0 -1 2
Get elements on CUDA device:
2 -1 0 0 0
-1 2 -1 0 0
0 -1 2 -1 0
0 0 -1 2 -1
0 0 0 -1 2

◆ getIndexer() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
__cuda_callable__ auto TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getIndexer

This method returns matrix elements indexer used by this matrix.

Returns
non-constant reference to the indexer.

◆ getIndexer() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
__cuda_callable__ auto TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getIndexer

This method returns matrix elements indexer used by this matrix.

Returns
constant reference to the indexer.

◆ getNonzeroElementsCount()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
Index TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getNonzeroElementsCount
overridevirtual

Returns number of non-zero matrix elements.

This method really counts the non-zero matrix elements and so it returns zero for matrix having all allocated elements set to zero.

Returns
number of non-zero matrix elements.

Reimplemented from TNL::Matrices::MatrixView< double, Devices::Host, int >.

◆ getPaddingIndex()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
__cuda_callable__ Index TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getPaddingIndex

Returns padding index denoting padding zero elements.

These elements are used for efficient data alignment in memory.

Returns
value of the padding index.

◆ getRow() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
__cuda_callable__ auto TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getRow ( const IndexType rowIdx)

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

Parameters
rowIdxis matrix row index.
Returns
RowView for accessing given matrix row.
Example
#include <iostream>
#include <TNL/Algorithms/ParallelFor.h>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void getRowExample()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 2 -1 . . . \ -> { 0, 0, 1 }
* | -1 2 -1 . . | -> { 0, 2, 1 }
* | . -1 2 -1. . | -> { 3, 2, 1 }
* | . . -1 2 -1 | -> { 3, 2, 1 }
* \ . . . -1 2 / -> { 3, 2, 1 }
*
*/
const int matrixSize( 5 );
MatrixType matrix(
matrixSize, // number of matrix rows
matrixSize // number of matrix columns
);
auto view = matrix.getView();
auto f = [=] __cuda_callable__ ( int rowIdx ) mutable {
auto row = view.getRow( rowIdx );
if( rowIdx > 0 )
row.setElement( 0, -1.0 ); // elements below the diagonal
row.setElement( 1, 2.0 ); // elements on the diagonal
if( rowIdx < matrixSize - 1 ) // elements above the diagonal
row.setElement( 2, -1.0 );
};
/***
* Set the matrix elements.
*/
std::cout << std::endl << matrix << std::endl;
}
int main( int argc, char* argv[] )
{
std::cout << "Getting matrix rows on host: " << std::endl;
getRowExample< TNL::Devices::Host >();
#ifdef HAVE_CUDA
std::cout << "Getting matrix rows on CUDA device: " << std::endl;
getRowExample< TNL::Devices::Cuda >();
#endif
}
static void exec(Index start, Index end, Function f, FunctionArgs... args)
Static method for the execution of the loop.
Definition: ParallelFor.h:87
Output
Getting matrix rows on host:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2
Getting matrix rows on CUDA device:
Row: 0 -> 0:2 1:-1
Row: 1 -> 0:-1 1:2 2:-1
Row: 2 -> 1:-1 2:2 3:-1
Row: 3 -> 2:-1 3:2 4:-1
Row: 4 -> 3:-1 4:2

See TridiagonalMatrixRowView.

◆ getRow() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
__cuda_callable__ auto TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getRow ( const IndexType rowIdx) const

Constant getter of simple structure for accessing given matrix row.

Parameters
rowIdxis matrix row index.
Returns
RowView for accessing given matrix row.
Example
#include <iostream>
#include <functional>
#include <TNL/Algorithms/ParallelFor.h>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void getRowExample()
{
const int matrixSize = 5;
MatrixType matrix (
matrixSize, // number of matrix columns
{ { 0.0, 2.0, 1.0 }, // matrix elements
{ 0.0, 2.0, 1.0 },
{ 3.0, 2.0, 1.0 },
{ 3.0, 2.0, 1.0 },
{ 0.0, 2.0, 1.0 } } );
auto view = matrix.getView();
/***
* Fetch lambda function returns diagonal element in each row.
*/
auto fetch = [=] __cuda_callable__ ( int rowIdx ) mutable -> double {
auto row = view.getRow( rowIdx );
return row.getValue( 2 ); // get value from subdiagonal with index 2, i.e. the main diagonal
};
/***
* Compute the matrix trace.
*/
int trace = TNL::Algorithms::reduce< Device >( 0, view.getRows(), fetch, std::plus<>{}, 0 );
std::cout << "Matrix reads as: " << std::endl << matrix << std::endl;
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 HAVE_CUDA
std::cout << "Getting matrix rows on CUDA device: " << std::endl;
getRowExample< TNL::Devices::Cuda >();
#endif
}
Output
Getting matrix rows on host:
Matrix reads as:
Row: 0 -> 0:2 1:1
Row: 1 -> 1:2 2:1
Row: 2 -> 1:3 2:2 3:1
Row: 3 -> 2:3 3:2 4:1
Row: 4 -> 4:2
Matrix trace is: 5.
Getting matrix rows on CUDA device:
Matrix reads as:
Row: 0 -> 0:2 1:1
Row: 1 -> 1:2 2:1
Row: 2 -> 1:3 2:2 3:1
Row: 3 -> 2:3 3:2 4:1
Row: 4 -> 4:2
Matrix trace is: 5.

See TridiagonalMatrixRowView.

◆ getRowCapacities()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Vector >
void TNL::Matrices::TridiagonalMatrixView< 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
rowCapacitiesis a vector where the row capacities will be stored.

◆ getSerializationType()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
std::string TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getSerializationType
static

Returns string with serialization type.

The string has a form Matrices::TridiagonalMatrix< RealType, [any_device], IndexType, Organization, [any_allocator] >.

See TridiagonalMatrix::getSerializationType.

Returns
String with the serialization type.

◆ getSerializationTypeVirtual()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
std::string TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getSerializationTypeVirtual
overridevirtual

Returns string with serialization type.

See TridiagonalMatrix::getSerializationType.

Returns
String with the serialization type.

Reimplemented from TNL::Object.

◆ getView()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
auto TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::getView

Returns a modifiable view of the tridiagonal matrix.

Returns
tridiagonal matrix view.

◆ operator!=()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Real_ , typename Device_ , typename Index_ , ElementsOrganization Organization_>
bool TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::operator!= ( const TridiagonalMatrixView< Real_, Device_, Index_, Organization_ > &  matrix) const

Comparison operator with another multidiagonal matrix.

Template Parameters
Real_is Real type of the source matrix.
Device_is Device type of the source matrix.
Index_is Index type of the source matrix.
Organization_is Organization of the source matrix.
Parameters
matrixis the source matrix view.
Returns
true if both matrices are NOT identical and false otherwise.

◆ operator=()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
TridiagonalMatrixView< Real, Device, Index, Organization > & TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::operator= ( const TridiagonalMatrixView< Real, Device, Index, Organization > &  view)

Assignment of exactly the same matrix type.

Parameters
viewis input matrix view for the assignment.
Returns
reference to this matrix.

◆ operator==()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Real_ , typename Device_ , typename Index_ , ElementsOrganization Organization_>
bool TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::operator== ( const TridiagonalMatrixView< Real_, Device_, Index_, Organization_ > &  matrix) const

Comparison operator with another tridiagonal matrix.

Template Parameters
Real_is Real type of the source matrix.
Device_is Device type of the source matrix.
Index_is Index type of the source matrix.
Organization_is Organization of the source matrix.
Parameters
matrixis the source matrix view.
Returns
true if both matrices are identical and false otherwise.

◆ print()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::print ( std::ostream str) const
overridevirtual

Method for printing the matrix to output stream.

Parameters
stris the output stream.

Reimplemented from TNL::Matrices::MatrixView< double, Devices::Host, int >.

◆ reduceAllRows() [1/2]

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

Method for performing general reduction on all matrix rows.

Template Parameters
Fetchis 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
Reduceis a type of lambda function for reduction declared as
auto reduce = [=] __cuda_callable__ ( const FetchValue& v1, const FetchValue& v2 ) -> FetchValue { ... };
Result reduce(Index begin, Index end, Fetch &&fetch, Reduction &&reduction, const Result &identity)
reduce implements (parallel) reduction for vectors and arrays.
Definition: reduce.h:71
Template Parameters
Keepis a type of lambda function for storing results of reduction in each row. It is declared as
auto keep = [=] __cuda_callable__ ( const IndexType rowIdx, const double& value ) { ... };
Template Parameters
FetchValueis type returned by the Fetch lambda function.
Parameters
fetchis an instance of lambda function for data fetch.
reduceis an instance of lambda function for reduction.
keepin an instance of lambda function for storing results.
identityis 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/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
template< typename Device >
void reduceRows()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 1 3 . . . \ -> { 0, 1, 3 }
* | 2 1 3 . . | -> { 2, 1, 3 }
* | . 2 1 3 . | -> { 2, 1, 3 }
* | . . 2 1 3 | -> { 2, 1, 3 }
* \ . . . 2 1 / 0 -> { 2, 1, 0 }
*
*/
5, // number of matrix columns
{ { 0, 1, 3 }, // matrix elements
{ 2, 1, 3 },
{ 2, 1, 3 },
{ 2, 1, 3 },
{ 2, 1, 3 } } );
auto view = matrix.getView();
/***
* 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.
*/
view.reduceAllRows( fetch, reduce, keep, std::numeric_limits< double >::lowest() );
std::cout << "The matrix reads as: " << std::endl << matrix << std::endl;
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 HAVE_CUDA
std::cout << "Rows reduction on CUDA device:" << std::endl;
reduceRows< TNL::Devices::Cuda >();
#endif
}
void reduceRows(IndexType begin, IndexType end, Fetch &fetch, Reduce &reduce, Keep &keep, const FetchReal &identity) const
Method for performing general reduction on matrix rows for constant instances.
Definition: TridiagonalMatrixView.hpp:210
void reduceAllRows(Fetch &fetch, Reduce &reduce, Keep &keep, const FetchReal &identity)
Method for performing general reduction on all matrix rows.
Definition: TridiagonalMatrix.hpp:270
__cuda_callable__ T abs(const T &n)
This function returns absolute value of given number n.
Definition: Math.h:87
constexpr ResultType max(const T1 &a, const T2 &b)
This function returns maximum of two numbers.
Definition: Math.h:61
Output
Rows reduction on host:
The matrix reads as:
Row: 0 -> 0:1 1:3
Row: 1 -> 0:2 1:1 2:3
Row: 2 -> 1:2 2:1 3:3
Row: 3 -> 2:2 3:1 4:3
Row: 4 -> 3:2 4:1
Max. elements in rows are: [ 3, 3, 3, 3, 2 ]
Rows reduction on CUDA device:
The matrix reads as:
Row: 0 -> 0:1 1:3
Row: 1 -> 0:2 1:1 2:3
Row: 2 -> 1:2 2:1 3:3
Row: 3 -> 2:2 3:1 4:3
Row: 4 -> 3:2 4:1
Max. elements in rows are: [ 3, 3, 3, 3, 2 ]

◆ reduceAllRows() [2/2]

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

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

Template Parameters
Fetchis 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
Reduceis a type of lambda function for reduction declared as
auto reduce = [=] __cuda_callable__ ( const FetchValue& v1, const FetchValue& v2 ) -> FetchValue { ... };
Template Parameters
Keepis a type of lambda function for storing results of reduction in each row. It is declared as
auto keep = [=] __cuda_callable__ ( const IndexType rowIdx, const double& value ) { ... };
Template Parameters
FetchValueis type returned by the Fetch lambda function.
Parameters
fetchis an instance of lambda function for data fetch.
reduceis an instance of lambda function for reduction.
keepin an instance of lambda function for storing results.
identityis 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/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
template< typename Device >
void reduceRows()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 1 3 . . . \ -> { 0, 1, 3 }
* | 2 1 3 . . | -> { 2, 1, 3 }
* | . 2 1 3 . | -> { 2, 1, 3 }
* | . . 2 1 3 | -> { 2, 1, 3 }
* \ . . . 2 1 / 0 -> { 2, 1, 0 }
*
*/
5, // number of matrix columns
{ { 0, 1, 3 }, // matrix elements
{ 2, 1, 3 },
{ 2, 1, 3 },
{ 2, 1, 3 },
{ 2, 1, 3 } } );
auto view = matrix.getView();
/***
* 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.
*/
view.reduceAllRows( fetch, reduce, keep, std::numeric_limits< double >::lowest() );
std::cout << "The matrix reads as: " << std::endl << matrix << std::endl;
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 HAVE_CUDA
std::cout << "Rows reduction on CUDA device:" << std::endl;
reduceRows< TNL::Devices::Cuda >();
#endif
}
Output
Rows reduction on host:
The matrix reads as:
Row: 0 -> 0:1 1:3
Row: 1 -> 0:2 1:1 2:3
Row: 2 -> 1:2 2:1 3:3
Row: 3 -> 2:2 3:1 4:3
Row: 4 -> 3:2 4:1
Max. elements in rows are: [ 3, 3, 3, 3, 2 ]
Rows reduction on CUDA device:
The matrix reads as:
Row: 0 -> 0:1 1:3
Row: 1 -> 0:2 1:1 2:3
Row: 2 -> 1:2 2:1 3:3
Row: 3 -> 2:2 3:1 4:3
Row: 4 -> 3:2 4:1
Max. elements in rows are: [ 3, 3, 3, 3, 2 ]

◆ reduceRows() [1/2]

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

Method for performing general reduction on matrix rows.

Template Parameters
Fetchis 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
Reduceis a type of lambda function for reduction declared as
auto reduce( const FetchValue& v1, const FetchValue& v2 ) -> FetchValue { ... };
Template Parameters
Keepis a type of lambda function for storing results of reduction in each row. It is declared as
auto keep = [=] __cuda_callable__ ( const IndexType rowIdx, const double& value ) { ... };
Template Parameters
FetchValueis type returned by the Fetch lambda function.
Parameters
begindefines beginning of the range [ begin, end ) of rows to be processed.
enddefines ending of the range [ begin, end ) of rows to be processed.
fetchis an instance of lambda function for data fetch.
reduceis an instance of lambda function for reduction.
keepin an instance of lambda function for storing results.
identityis 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/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
template< typename Device >
void reduceRows()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 1 3 . . . \ -> { 0, 1, 3 }
* | 2 1 3 . . | -> { 2, 1, 3 }
* | . 2 1 3 . | -> { 2, 1, 3 }
* | . . 2 1 3 | -> { 2, 1, 3 }
* \ . . . 2 1 / 0 -> { 2, 1, 0 }
*
*/
5, // number of matrix columns
{ { 0, 1, 3 }, // matrix elements
{ 2, 1, 3 },
{ 2, 1, 3 },
{ 2, 1, 3 },
{ 2, 1, 3 } } );
auto view = matrix.getView();
/***
* 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.
*/
view.reduceRows( 0, view.getRows(), fetch, reduce, keep, std::numeric_limits< double >::lowest() );
std::cout << "The matrix reads as: " << std::endl << matrix << std::endl;
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 HAVE_CUDA
std::cout << "Rows reduction on CUDA device:" << std::endl;
reduceRows< TNL::Devices::Cuda >();
#endif
}
__cuda_callable__ IndexType getRows() const
Returns number of matrix rows.
Definition: Matrix.hpp:69
void reduceRows(IndexType begin, IndexType end, Fetch &fetch, Reduce &reduce, Keep &keep, const FetchReal &identity)
Method for performing general reduction on matrix rows.
Definition: TridiagonalMatrix.hpp:246
Output
Rows reduction on host:
The matrix reads as:
Row: 0 -> 0:1 1:3
Row: 1 -> 0:2 1:1 2:3
Row: 2 -> 1:2 2:1 3:3
Row: 3 -> 2:2 3:1 4:3
Row: 4 -> 3:2 4:1
Max. elements in rows are: [ 3, 3, 3, 3, 2 ]
Rows reduction on CUDA device:
The matrix reads as:
Row: 0 -> 0:1 1:3
Row: 1 -> 0:2 1:1 2:3
Row: 2 -> 1:2 2:1 3:3
Row: 3 -> 2:2 3:1 4:3
Row: 4 -> 3:2 4:1
Max. elements in rows are: [ 3, 3, 3, 3, 2 ]

◆ reduceRows() [2/2]

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

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

Template Parameters
Fetchis 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
Reduceis a type of lambda function for reduction declared as
auto reduce = [=] __cuda_callable__ ( const FetchValue& v1, const FetchValue& v2 ) -> FetchValue { ... };
Template Parameters
Keepis a type of lambda function for storing results of reduction in each row. It is declared as
auto keep = [=] __cuda_callable__ ( const IndexType rowIdx, const double& value ) { ... };
Template Parameters
FetchValueis type returned by the Fetch lambda function.
Parameters
begindefines beginning of the range [ begin, end ) of rows to be processed.
enddefines ending of the range [ begin, end ) of rows to be processed.
fetchis an instance of lambda function for data fetch.
reduceis an instance of lambda function for reduction.
keepin an instance of lambda function for storing results.
identityis 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/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
template< typename Device >
void reduceRows()
{
/***
* Set the following matrix (dots represent zero matrix elements and zeros are
* padding zeros for memory alignment):
*
* 0 / 1 3 . . . \ -> { 0, 1, 3 }
* | 2 1 3 . . | -> { 2, 1, 3 }
* | . 2 1 3 . | -> { 2, 1, 3 }
* | . . 2 1 3 | -> { 2, 1, 3 }
* \ . . . 2 1 / 0 -> { 2, 1, 0 }
*
*/
5, // number of matrix columns
{ { 0, 1, 3 }, // matrix elements
{ 2, 1, 3 },
{ 2, 1, 3 },
{ 2, 1, 3 },
{ 2, 1, 3 } } );
auto view = matrix.getView();
/***
* 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.
*/
view.reduceRows( 0, view.getRows(), fetch, reduce, keep, std::numeric_limits< double >::lowest() );
std::cout << "The matrix reads as: " << std::endl << matrix << std::endl;
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 HAVE_CUDA
std::cout << "Rows reduction on CUDA device:" << std::endl;
reduceRows< TNL::Devices::Cuda >();
#endif
}
Output
Rows reduction on host:
The matrix reads as:
Row: 0 -> 0:1 1:3
Row: 1 -> 0:2 1:1 2:3
Row: 2 -> 1:2 2:1 3:3
Row: 3 -> 2:2 3:1 4:3
Row: 4 -> 3:2 4:1
Max. elements in rows are: [ 3, 3, 3, 3, 2 ]
Rows reduction on CUDA device:
The matrix reads as:
Row: 0 -> 0:1 1:3
Row: 1 -> 0:2 1:1 2:3
Row: 2 -> 1:2 2:1 3:3
Row: 3 -> 2:2 3:1 4:3
Row: 4 -> 3:2 4:1
Max. elements in rows are: [ 3, 3, 3, 3, 2 ]

◆ save() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::save ( const String fileName) const

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

Parameters
fileNameis name of the file.

◆ save() [2/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::save ( File file) const
overridevirtual

Method for saving the matrix to a file.

Parameters
fileis the output file.

Reimplemented from TNL::Object.

◆ sequentialForAllRows() [1/2]

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename Function >
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::sequentialForAllRows ( Function &  function)

This method calls sequentialForRows for all matrix rows.

See TridiagonalMatrixView::sequentialForAllRows.

Template Parameters
Functionis a type of lambda function that will operate on matrix elements.
Parameters
functionis 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::TridiagonalMatrixView< Real, Device, Index, Organization >::sequentialForAllRows ( Function &  function) const

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

See TridiagonalMatrixView::sequentialForRows.

Template Parameters
Functionis a type of lambda function that will operate on matrix elements.
Parameters
functionis 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::TridiagonalMatrixView< 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
Functionis 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::TridiagonalMatrixView::RowView.

Parameters
begindefines beginning of the range [ begin, end ) of rows to be processed.
enddefines ending of the range [ begin, end ) of rows to be processed.
functionis 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::TridiagonalMatrixView< 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
Functionis 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::TridiagonalMatrixView::RowView.

Parameters
begindefines beginning of the range [ begin, end ) of rows to be processed.
enddefines ending of the range [ begin, end ) of rows to be processed.
functionis 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::TridiagonalMatrixView< 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. TridiagonalMatrix::getRow or TridiagonalMatrix::forElements and TridiagonalMatrix::forAllElements. The call may fail if the matrix row capacity is exhausted.

Parameters
rowis row index of the element.
columnis columns index of the element.
valueis the value the element will be set to.
Example
#include <iostream>
#include <TNL/Algorithms/ParallelFor.h>
#include <TNL/Matrices/TridiagonalMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
template< typename Device >
void setElements()
{
const int matrixSize( 5 );
Matrix matrix( matrixSize, matrixSize );
auto view = matrix.getView();
for( int i = 0; i < 5; i++ )
view.setElement( i, i, i );
std::cout << "Matrix set from the host:" << std::endl;
std::cout << matrix << std::endl;
auto f = [=] __cuda_callable__ ( int i ) mutable {
if( i > 0 )
view.setElement( i, i - 1, 1.0 );
view.setElement( i, i, -i );
if( i < matrixSize - 1 )
view.setElement( i, i + 1, 1.0 );
};
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 HAVE_CUDA
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 ->
Row: 1 -> 1:1
Row: 2 -> 2:2
Row: 3 -> 3:3
Row: 4 -> 4:4
Matrix set from its native device:
Row: 0 -> 1:1
Row: 1 -> 0:1 1:-1 2:1
Row: 2 -> 1:1 2:-2 3:1
Row: 3 -> 2:1 3:-3 4:1
Row: 4 -> 3:1 4:-4
Set elements on CUDA device:
Matrix set from the host:
Row: 0 ->
Row: 1 -> 1:1
Row: 2 -> 2:2
Row: 3 -> 3:3
Row: 4 -> 4:4
Matrix set from its native device:
Row: 0 -> 1:1
Row: 1 -> 0:1 1:-1 2:1
Row: 2 -> 1:1 2:-2 3:1
Row: 3 -> 2:1 3:-3 4:1
Row: 4 -> 3:1 4:-4

◆ setValue()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::setValue ( const RealType value)

Set all matrix elements to given value.

Parameters
valueis the new value of all matrix elements.

◆ vectorProduct()

template<typename Real , typename Device , typename Index , ElementsOrganization Organization>
template<typename InVector , typename OutVector >
void TNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization >::vectorProduct ( const InVector &  inVector,
OutVector &  outVector,
RealType  matrixMultiplicator = 1.0,
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
InVectoris type of input vector. It can be TNL::Containers::Vector, TNL::Containers::VectorView, TNL::Containers::Array, TNL::Containers::ArrayView, or similar container.
OutVectoris type of output vector. It can be TNL::Containers::Vector, TNL::Containers::VectorView, TNL::Containers::Array, TNL::Containers::ArrayView, or similar container.
Parameters
inVectoris input vector.
outVectoris output vector.
matrixMultiplicatoris a factor by which the matrix is multiplied. It is one by default.
outVectorMultiplicatoris a factor by which the outVector is multiplied before added to the result of matrix-vector product. It is zero by default.
beginis the beginning of the rows range for which the vector product is computed. It is zero by default.
endis the end of the rows range for which the vector product is computed. It is number if the matrix rows by default.

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