diff --git a/Documentation/Examples/Matrices/DenseMatrix/CMakeLists.txt b/Documentation/Examples/Matrices/DenseMatrix/CMakeLists.txt
index e2814577681fa85d54b707b091f7d86fe7dcd49e..d88862afb2338e5e4581ce2f8204291f919a5cd8 100644
--- a/Documentation/Examples/Matrices/DenseMatrix/CMakeLists.txt
+++ b/Documentation/Examples/Matrices/DenseMatrix/CMakeLists.txt
@@ -26,6 +26,7 @@ set( COMMON_EXAMPLES
DenseMatrixViewExample_forElements
DenseMatrixViewExample_forRows
DenseMatrixViewExample_forAllElements
+ DenseMatrixViewExample_wrap
)
if( BUILD_CUDA )
diff --git a/Documentation/Examples/Matrices/DenseMatrix/DenseMatrixViewExample_wrap.cpp b/Documentation/Examples/Matrices/DenseMatrix/DenseMatrixViewExample_wrap.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..81919146816ee771de4ac0626d14b2315c490460
--- /dev/null
+++ b/Documentation/Examples/Matrices/DenseMatrix/DenseMatrixViewExample_wrap.cpp
@@ -0,0 +1,34 @@
+#include <iostream>
+#include <TNL/Algorithms/ParallelFor.h>
+#include <TNL/Matrices/DenseMatrix.h>
+#include <TNL/Matrices/MatrixWrapping.h>
+#include <TNL/Devices/Host.h>
+#include <TNL/Devices/Cuda.h>
+
+template< typename Device >
+void wrapMatrixView()
+{
+ const int rows( 3 ), columns( 4 );
+ TNL::Containers::Vector< double, Device > valuesVector {
+ 1, 2, 3, 4,
+ 5, 6, 7, 8,
+ 9, 10, 11, 12 };
+ double* values = valuesVector.getData();
+
+ /***
+ * Wrap the array `values` to dense matrix view
+ */
+ auto matrix = TNL::Matrices::wrapDenseMatrix< Device >( rows, columns, values );
+ std::cout << "Matrix reads as: " << std::endl << matrix << std::endl;
+}
+
+int main( int argc, char* argv[] )
+{
+ std::cout << "Wraping matrix view on host: " << std::endl;
+ wrapMatrixView< TNL::Devices::Host >();
+
+#ifdef HAVE_CUDA
+ std::cout << "Wraping matrix view on CUDA device: " << std::endl;
+ wrapMatrixView< TNL::Devices::Cuda >();
+#endif
+}
diff --git a/Documentation/Examples/Matrices/DenseMatrix/DenseMatrixViewExample_wrap.cu b/Documentation/Examples/Matrices/DenseMatrix/DenseMatrixViewExample_wrap.cu
new file mode 120000
index 0000000000000000000000000000000000000000..fbdc1d8bb41c18719f26e47cf4abb680d7d6e92f
--- /dev/null
+++ b/Documentation/Examples/Matrices/DenseMatrix/DenseMatrixViewExample_wrap.cu
@@ -0,0 +1 @@
+DenseMatrixViewExample_wrap.cpp
\ No newline at end of file
diff --git a/Documentation/Examples/Matrices/SparseMatrix/CMakeLists.txt b/Documentation/Examples/Matrices/SparseMatrix/CMakeLists.txt
index c2db3879eea91791f4ee5239e3cb1acda1092702..641534bae21216ab91fe798af67715440f763c5f 100644
--- a/Documentation/Examples/Matrices/SparseMatrix/CMakeLists.txt
+++ b/Documentation/Examples/Matrices/SparseMatrix/CMakeLists.txt
@@ -30,6 +30,8 @@ set( COMMON_EXAMPLES
SparseMatrixViewExample_forElements
SparseMatrixViewExample_forRows
SparseMatrixViewExample_forAllElements
+ SparseMatrixViewExample_wrapCSR
+ SparseMatrixViewExample_wrapEllpack
)
if( BUILD_CUDA )
diff --git a/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapCSR.cpp b/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapCSR.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c574bb7a0f52371cf40a35c5e8bba3f85c880ab
--- /dev/null
+++ b/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapCSR.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <TNL/Algorithms/ParallelFor.h>
+#include <TNL/Matrices/DenseMatrix.h>
+#include <TNL/Matrices/MatrixWrapping.h>
+#include <TNL/Devices/Host.h>
+#include <TNL/Devices/Cuda.h>
+
+template< typename Device >
+void wrapMatrixView()
+{
+ /***
+ * Encode the following matrix to CSR format...
+ *
+ * / 1 2 0 0 \.
+ * | 0 6 0 0 |
+ * | 9 0 0 0 |
+ * \ 0 0 15 16 /
+ */
+ const int rows( 4 ), columns( 4 );
+ TNL::Containers::Vector< double, Device > valuesVector { 1, 2, 6, 9, 15, 16 };
+ TNL::Containers::Vector< int, Device > columnIndexesVector { 0, 1, 1, 0, 2, 3 };
+ TNL::Containers::Vector< int, Device > rowPointersVector { 0, 2, 3, 4, 6 };
+
+ double* values = valuesVector.getData();
+ int* columnIndexes = columnIndexesVector.getData();
+ int* rowPointers = rowPointersVector.getData();
+
+ /***
+ * Wrap the arrays `rowPointers, `values` and `columnIndexes` to sparse matrix view
+ */
+ auto matrix = TNL::Matrices::wrapCSRMatrix< Device >( rows, columns, rowPointers, values, columnIndexes );
+
+ std::cout << "Matrix reads as: " << std::endl << matrix << std::endl;
+}
+
+int main( int argc, char* argv[] )
+{
+ std::cout << "Wraping matrix view on host: " << std::endl;
+ wrapMatrixView< TNL::Devices::Host >();
+
+#ifdef HAVE_CUDA
+ std::cout << "Wraping matrix view on CUDA device: " << std::endl;
+ wrapMatrixView< TNL::Devices::Cuda >();
+#endif
+}
diff --git a/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapCSR.cu b/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapCSR.cu
new file mode 120000
index 0000000000000000000000000000000000000000..6581b62dcbc8cc88eb84616f57dd933208df3823
--- /dev/null
+++ b/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapCSR.cu
@@ -0,0 +1 @@
+SparseMatrixViewExample_wrapCSR.cpp
\ No newline at end of file
diff --git a/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapEllpack.cpp b/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapEllpack.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9f36df57ec34130c6aaa2adf53afaa39c39a9911
--- /dev/null
+++ b/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapEllpack.cpp
@@ -0,0 +1,43 @@
+#include <iostream>
+#include <TNL/Algorithms/ParallelFor.h>
+#include <TNL/Matrices/DenseMatrix.h>
+#include <TNL/Matrices/MatrixWrapping.h>
+#include <TNL/Devices/Host.h>
+#include <TNL/Devices/Cuda.h>
+
+template< typename Device >
+void wrapMatrixView()
+{
+ /***
+ * Encode the following matrix to Ellpack format...
+ *
+ * / 1 2 0 0 \.
+ * | 0 6 0 0 |
+ * | 9 0 0 0 |
+ * \ 0 0 15 16 /
+ */
+ const int rows( 4 ), columns( 4 );
+ TNL::Containers::Vector< double, Device > valuesVector { 1, 2, 6, 0, 9, 0, 15, 16 };
+ TNL::Containers::Vector< int, Device > columnIndexesVector { 0, 1, 1, -1, 0, -1, 2, 3 };
+
+ double* values = valuesVector.getData();
+ int* columnIndexes = columnIndexesVector.getData();
+
+ /***
+ * Wrap the arrays `values` and `columnIndexes` to sparse matrix view
+ */
+ auto matrix = TNL::Matrices::wrapEllpackMatrix< Device >( rows, columns, 2, values, columnIndexes );
+
+ std::cout << "Matrix reads as: " << std::endl << matrix << std::endl;
+}
+
+int main( int argc, char* argv[] )
+{
+ std::cout << "Wraping matrix view on host: " << std::endl;
+ wrapMatrixView< TNL::Devices::Host >();
+
+#ifdef HAVE_CUDA
+ std::cout << "Wraping matrix view on CUDA device: " << std::endl;
+ wrapMatrixView< TNL::Devices::Cuda >();
+#endif
+}
diff --git a/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapEllpack.cu b/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapEllpack.cu
new file mode 120000
index 0000000000000000000000000000000000000000..3d0a09594910fd369499289eb2a7be62ccdeb964
--- /dev/null
+++ b/Documentation/Examples/Matrices/SparseMatrix/SparseMatrixViewExample_wrapEllpack.cu
@@ -0,0 +1 @@
+SparseMatrixViewExample_wrapEllpack.cpp
\ No newline at end of file
diff --git a/Documentation/Tutorials/Matrices/tutorial_Matrices.md b/Documentation/Tutorials/Matrices/tutorial_Matrices.md
index 5c60bece9e45b774ae332a531b1f5170ebd33d8b..1014c9103645245c97ad898241d9be8820a90762 100644
--- a/Documentation/Tutorials/Matrices/tutorial_Matrices.md
+++ b/Documentation/Tutorials/Matrices/tutorial_Matrices.md
@@ -432,6 +432,16 @@ The result looks as follows:
\include DenseMatrixExample_forElements.out
+#### Wrapping existing data to dense matrix view
+
+In case when you have already allocated data for dense matrix (for example in some other library), you may wrap it to dense matrix view with a function \ref TNL::Matrices::wrapDenseMatrix . See the following example:
+
+\includelineno DenseMatrixViewExample_wrap.cpp
+
+Here we create dense matrix having three rows and four columns. We use TNL vector (\ref TNL::Containers::Vector) only for allocation of the matrix elements (lines 12-15) and we get a pointer to the allocated array immediately (line 16). Next we use just the array to get dense matrix view with proper matrix dimensions (line 21). Note that we must explicitly state the device type as a template parameter of the function `wrapDenseMatrix` (\ref TNL::Matrices::wrapDenseMatrix). Finally, we print the matrix to see if it is correct (line 22). The result looks as follows:
+
+\include DenseMatrixViewExample_wrap.out
+
### Sparse matrices
[Sparse matrices](https://en.wikipedia.org/wiki/Sparse_matrix) are extremely important in a lot of numerical algorithms. They are used at situations when we need to operate with matrices having majority of the matrix elements equal to zero. In this case, only the non-zero matrix elements are stored with possibly some *padding zeros* used for memory alignment. This is necessary mainly on GPUs. See the [Overview of matrix types](#overview_of_matrix_types) for the differences in memory requirements.
@@ -647,6 +657,30 @@ would not make sense. If we pass through this test, the matrix element lies in t
\include SparseMatrixExample_forElements.out
+#### Wrapping existing data to sparse matrix view
+
+Standard sparse matrix format like [CSR](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format)) and [Ellpack](https://people.math.sc.edu/Burkardt/data/sparse_ellpack/sparse_ellpack.html) store the matrix elements in specifically defined arrays. In case that you have already allocated them (for example in some other library), they can be wrapped into a sparse matrix view with given matrix format. This can be done by means of functions \ref TNL::Matrices::wrapCSRMatrix and \ref TNL::Matrices::wrapEllpackMatrix . See the following example for demonstration of the CSR format:
+
+\includelineno SparseMatrixViewExample_wrapCSR.cpp
+
+We create sparse matrix having four rows and four columns (line 19). We use TNL vector (\ref TNL::Containers::Vector) to allocate arrays necessary for the CSR format:
+
+1. `valuesVector` (line 20) - contains values of the nonzero matrix elements.
+2. `columnIndexesVector` (line 21) - contains column indexes of the nonzero matrix elements.
+3. `rowPointersVector` (line 22) - contains positions of the first nonzero matrix elements in each row within `valuesVector` and `columnIndexesVector`. The size of this array equals number of matrix rows plus one.
+
+Next we turn the vectors into C style pointers (lines 24-26) to wrap them into sparse matrix view (line 31). Note, that we must explicitly state the device on which the arrays are allocated. Finlay we print the matrix to check the correctness (line 33). The result looks as follows:
+
+\include SparseMatrixViewExample_wrapCSR.out
+
+Wrapping data corresponding with the Ellpack format is very similar as we can see in the following example:
+
+\includelineno SparseMatrixViewExample_wrapEllpack.cpp
+
+We encode the same sparse matrix as in the previous example. The essence of the Ellpack format is that we allocate the same number of matrix elements for each row which is two in our example. For some matrix rows we use the padding zeros for which we set the column index to -1 (line 21). Therefore the size of `valuesVector` and `columnIndexesVector` equals number of matrix rows times number of matrix elements allocated in each row. As before, we turn the vectors into C style pointers (lines 23-24) and wrap them into sparse matrix view with Ellpack format (line 29). Note that we must state the device on which the arrays are allocated explicitly. The result looks as follows:
+
+\include SparseMatrixViewExample_wrapEllpack.out
+
#### Symmetric sparse matrices
For sparse [symmetric matrices](https://en.wikipedia.org/wiki/Symmetric_matrix), TNL offers a format storing only a half of the matrix elements. More precisely, ony the matrix diagonal and the elements bellow are stored in the memory. The matrix elements above the diagonal are deduced from those bellow. If such a symmetric format is used on GPU, atomic operations must be used in some matrix operations. For this reason, symmetric matrices can be combined only with matrix elements values expressed in `float` or `double` type. An advantage of the symmetric formats is lower memory consumption. Since less data need to be transferred from the memory, better performance might be observed. In some cases, however, the use of atomic operations on GPU may cause performance drop. Mostly we can see approximately the same performance compared to general formats but we can profit from lower memory requirements which is appreciated especially on GPU. The following example shows how to create symmetric sparse matrix.
@@ -833,7 +867,7 @@ The output of the example looks as:
\include TridiagonalMatrixExample_Constructor_init_list_1.out
-#### Methods `setElement` and `addElement`
+#### Methods setElement and addElement
Similar way of the tridiagonal matrix setup is offered by the method `setElements` (\ref TNL::Matrices::TridiagonalMatrix::setElements) as the following example demonstrates:
@@ -851,7 +885,7 @@ The result looks as follows:
\include TridiagonalMatrixExample_setElement.out
-#### Method `getRow`
+#### Method getRow
A bit different way of setting up the matrix, is the use of tridiagonal matrix view and the method `getRow` (\ref TNL::Matrices::TridiagonalMatrixView::getRow) as the following example demonstrates:
@@ -863,7 +897,7 @@ The result looks as follows:
\include TridiagonalMatrixViewExample_getRow.out
-### Method `forRows`
+#### Method forRows
As in the case of other matrix types, the method `forRows` (\ref TNL::Matrices::TridiagonalMatrix::forRows) calls the method `getRow` (\ref TNL::Matrices::TridiagonalMatrix::getRow) in parallel. It is demonstrated by the following example which we may directly compare with the previous one:
@@ -881,7 +915,7 @@ The result looks as follows:
\include TridiagonalMatrixExample_forRows.out
-#### Method `forElements`
+#### Method forElements
Finally, even a bit more simple way of matrix elements manipulation with the method `forElements` (\ref TNL::Matrices::TridiagonalMatrix::forElements) is demonstrated in the following example:
@@ -1043,7 +1077,7 @@ On the lines 25-46, we call the constructor which, in addition to matrix dimensi
\include MultidiagonalMatrixExample_Constructor_init_list_2.out
-#### Methods `setElement` and `addElement`
+#### Methods setElement and addElement
Another and more efficient way of setting the matrix elements is by means of the method `setElement` (\ref TNL::Matrices::MultidiagonalMatrix::setElement). It is demonstrated in the following example:
@@ -1053,7 +1087,7 @@ This examples shows that the method `setElement` can be used both on the host (C
\include MultidiagonalMatrixViewExample_setElement.out
-#### Method `getRow`
+#### Method getRow
Slightly more efficient way of the multidiagonal matrix setup is offered by the method `getRow` (\ref TNL::Matrices::MultidiagonalMatrix::getRow). We will use it to create a matrix of the following form:
@@ -1137,7 +1171,7 @@ We use `ParallelFor2D` (\ref TNL::Algorithms::ParallelFor2D) to iterate over all
\include MultidiagonalMatrixExample_Constructor.out
-### Method `forRows`
+#### Method forRows
As in the case of other matrix types, the method `forRows` (\ref TNL::Matrices::MultidiagonalMatrix::forRows) calls the method `getRow` (\ref TNL::Matrices::MultidiagonalMatrix::getRow) in parallel. It is demonstrated by the following example:
@@ -1151,7 +1185,7 @@ The result looks as follows:
\include MultidiagonalMatrixExample_forRows.out
-#### Method `forElements`
+#### Method forElements
Similar and even a bit simpler way of setting the matrix elements is offered by the method `forElements` (\ref TNL::Matrices::MultidiagonalMatrix::forElements, \ref TNL::Matrices::MultidiagonalMatrixView::forElements) as demonstrated in the following example:
@@ -1220,7 +1254,7 @@ The result looks as follows:
\include LambdaMatrixExample_Constructor.out
-#### Method `forRows`
+#### Method forRows
Method `forRows` (\ref TNL::Matrices::LambdaMatrix::forRows, \ref TNL::Matrices::LambdaMatrix::forAllRows) iterates in parallel over all matrix rows. In the case of lambda matrices, it cannot be used for changing the matrix elements since they cannot be changed. In the following example, we show how to use this method to copy the matrix elements values to the dense matrix:
@@ -1238,7 +1272,7 @@ The result looks as follows:
\include LambdaMatrixExample_forRows.out
-#### Method `forElements`
+#### Method forElements
The lambda matrix has the same interface as other matrix types except of the method `getRow`. The following example demonstrates the use of the method `forElements` (\ref TNL::Matrices::LambdaMatrix::forElements) to copy the lambda matrix into the dense matrix:
diff --git a/src/TNL/Matrices/MatrixWrapping.h b/src/TNL/Matrices/MatrixWrapping.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa91de8315de528ddf16730a8138f0f89673b6b5
--- /dev/null
+++ b/src/TNL/Matrices/MatrixWrapping.h
@@ -0,0 +1,155 @@
+/***************************************************************************
+ MatrixWrapping.h - description
+ -------------------
+ begin : May 3, 2021
+ copyright : (C) 2021 by Tomas Oberhuber
+ email : tomas.oberhuber@fjfi.cvut.cz
+ ***************************************************************************/
+
+/* See Copyright Notice in tnl/Copyright */
+
+#pragma once
+
+#include <TNL/Algorithms/Segments/CSR.h>
+#include <TNL/Algorithms/Segments/Ellpack.h>
+#include <TNL/Matrices/SparseMatrixView.h>
+#include <TNL/Matrices/DenseMatrixView.h>
+
+namespace TNL {
+namespace Matrices {
+
+/**
+ * \brief Function for wrapping an array of values into a dense matrix view.
+ *
+ * \tparam Device is a device on which the array is allocated.
+ * \tparam Real is a type of array elements.
+ * \tparam Index is a type for indexing of matrix elements.
+ * \tparam Organization is matrix elements organization - see \ref TNL::Algorithms::Segments::ElementsOrganization.
+ * \param rows is a number of matrix rows.
+ * \param columns is a number of matrix columns.
+ * \param values is the array with matrix elements values.
+ * \return instance of DenseMatrixView wrapping the array.
+ *
+ * The array size must be equal to product of `rows` and `columns`. The dense matrix view does not deallocate the input
+ * array at the end of its lifespan.
+ *
+ * \par Example
+ * \include Matrices/DenseMatrix/DenseMatrixViewExample_wrap.cpp
+ * \par Output
+ * \include DenseMatrixViewExample_wrap.out
+ */
+template< typename Device,
+ typename Real,
+ typename Index,
+ ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization() >
+DenseMatrixView< Real, Device, Index, Organization >
+wrapDenseMatrix( const Index& rows, const Index& columns, Real* values )
+{
+ using MatrixView = DenseMatrixView< Real, Device, Index, Organization >;
+ using ValuesViewType = typename MatrixView::ValuesViewType;
+ return MatrixView( rows, columns, ValuesViewType( values, rows * columns ) );
+}
+
+/**
+ * \brief Function for wrapping of arrays defining [CSR format](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format)) into a sparse matrix view.
+ *
+ * \tparam Device is a device on which the arrays are allocated.
+ * \tparam Real is a type of matrix elements values.
+ * \tparam Index is a type for matrix elements indexing.
+ * \param rows is a number of matrix rows.
+ * \param columns is a number of matrix columns.
+ * \param rowPointers is an array holding row pointers of the CSR format ( `ROW_INDEX` [here](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format)))
+ * \param values is an array with values of matrix elements ( `V` [here](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format)))
+ * \param columnIndexes is an array with column indexes of matrix elements ( `COL_INDEX` [here](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format)))
+ * \return instance of SparseMatrixView with CSR format.
+ *
+ * The size of array \e rowPointers must be equal to number of `rows + 1`. The last element of the array equals to the number of all nonzero matrix elements. The sizes of arrays `values` and
+ * `columnIndexes` must be equal to this number.
+ *
+ * \par Example
+ * \include Matrices/SparseMatrix/SparseMatrixViewExample_wrapCSR.cpp
+ * \par Output
+ * \include SparseMatrixViewExample_wrapCSR.out
+ */
+template< typename Device,
+ typename Real,
+ typename Index >
+SparseMatrixView< Real, Device, Index, GeneralMatrix, Algorithms::Segments::CSRViewDefault >
+wrapCSRMatrix( const Index& rows, const Index& columns, Index* rowPointers, Real* values, Index* columnIndexes )
+{
+ using MatrixView = SparseMatrixView< Real, Device, Index, GeneralMatrix, Algorithms::Segments::CSRViewDefault >;
+ using ValuesViewType = typename MatrixView::ValuesViewType;
+ using ColumnIndexesView = typename MatrixView::ColumnsIndexesViewType;
+ using SegmentsView = typename MatrixView::SegmentsViewType;
+ using KernelView = typename SegmentsView::KernelView;
+ using RowPointersView = typename SegmentsView::OffsetsView;
+ RowPointersView rowPointersView( rowPointers, rows + 1 );
+ Index elementsCount = rowPointersView.getElement( rows );
+ SegmentsView segments( rowPointersView, KernelView() );
+ ValuesViewType valuesView( values, elementsCount );
+ ColumnIndexesView columnIndexesView( columnIndexes, elementsCount );
+ return MatrixView( rows, columns, valuesView, columnIndexesView, segments );
+}
+
+/// This is to prevent from appearing in Doxygen documentation.
+/// \cond HIDDEN_CLASS
+template< typename Device,
+ typename Real,
+ typename Index,
+ ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization(),
+ int Alignment = 1 >
+struct EllpackMatrixWrapper
+{
+ template< typename Device_, typename Index_ >
+ using EllpackSegments = Algorithms::Segments::EllpackView< Device_, Index_, Organization, Alignment >;
+ using MatrixView = SparseMatrixView< Real, Device, Index, GeneralMatrix, EllpackSegments >;
+
+ static MatrixView wrap( const Index& rows, const Index& columns, const Index& nonzerosPerRow, Real* values, Index* columnIndexes )
+ {
+ using ValuesViewType = typename MatrixView::ValuesViewType;
+ using ColumnIndexesView = typename MatrixView::ColumnsIndexesViewType;
+ using SegmentsView = Algorithms::Segments::EllpackView< Device, Index, Organization, Alignment >;
+ SegmentsView segments( rows, nonzerosPerRow );
+ Index elementsCount = segments.getStorageSize();
+ ValuesViewType valuesView( values, elementsCount );
+ ColumnIndexesView columnIndexesView( columnIndexes, elementsCount );
+ return MatrixView( rows, columns, valuesView, columnIndexesView, segments );
+ }
+};
+/// \endcond
+
+/**
+ * \brief Function for wrapping of arrays defining [Ellpack format](https://people.math.sc.edu/Burkardt/data/sparse_ellpack/sparse_ellpack.html) into a sparse matrix view.
+ *
+ * \tparam Device is a device on which the arrays are allocated.
+ * \tparam Real is a type of matrix elements values.
+ * \tparam Index is a type for matrix elements indexing.
+ * \tparam Alignment defines alignment of data. The number of matrix rows is rounded to a multiple of this number. It it usefull mainly for GPUs.
+ * \param rows is a number of matrix rows.
+ * \param columns is a number of matrix columns.
+ * \param nonzerosPerRow is number of nonzero matrix elements in each row.
+ * \param values is an array with values of matrix elements.
+ * \param columnIndexes is an array with column indexes of matrix elements.
+ * \return instance of SparseMatrixView with CSR format.
+ *
+ * The sizes of arrays `values` and `columnIndexes` must be equal to `rows * nonzerosPerRow`. Use `-1` as a column index for padding zeros.
+ *
+ * \par Example
+ * \include Matrices/SparseMatrix/SparseMatrixViewExample_wrapEllpack.cpp
+ * \par Output
+ * \include SparseMatrixViewExample_wrapEllpack.out
+ */
+template< typename Device,
+ typename Real,
+ typename Index,
+ ElementsOrganization Organization = Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization(),
+ int Alignment = 1 >
+auto
+wrapEllpackMatrix( const Index rows, const Index columns, const Index nonzerosPerRow, Real* values, Index* columnIndexes )
+-> decltype( EllpackMatrixWrapper< Device, Real, Index, Organization, Alignment >::wrap( rows, columns, nonzerosPerRow, values, columnIndexes ) )
+{
+ return EllpackMatrixWrapper< Device, Real, Index, Organization, Alignment >::wrap( rows, columns, nonzerosPerRow, values, columnIndexes );
+}
+
+ } //namespace Matrices
+} //namepsace TNL
diff --git a/src/UnitTests/Matrices/CMakeLists.txt b/src/UnitTests/Matrices/CMakeLists.txt
index 3210920f58089773cfc798c2f4592037dc4937a6..fa8876993cdce3c363fdfeb4bc5e8cee84e3a086 100644
--- a/src/UnitTests/Matrices/CMakeLists.txt
+++ b/src/UnitTests/Matrices/CMakeLists.txt
@@ -30,6 +30,7 @@ set( COMMON_TESTS
LambdaMatrixTest
SparseMatrixTest_SandboxMatrix
SparseMatrixVectorProductTest_SandboxMatrix
+ MatrixWrappingTest
)
set( CPP_TESTS
diff --git a/src/UnitTests/Matrices/MatrixWrappingTest.cpp b/src/UnitTests/Matrices/MatrixWrappingTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db87ce48232aedad8c57dd2e20129fa522b9b7e4
--- /dev/null
+++ b/src/UnitTests/Matrices/MatrixWrappingTest.cpp
@@ -0,0 +1,11 @@
+/***************************************************************************
+ MatrixWrappingTest.cpp - description
+ -------------------
+ begin : Mar 4, 2021
+ copyright : (C) 2021 by Tomas Oberhuber et al.
+ email : tomas.oberhuber@fjfi.cvut.cz
+ ***************************************************************************/
+
+/* See Copyright Notice in tnl/Copyright */
+
+#include "MatrixWrappingTest.h"
diff --git a/src/UnitTests/Matrices/MatrixWrappingTest.cu b/src/UnitTests/Matrices/MatrixWrappingTest.cu
new file mode 100644
index 0000000000000000000000000000000000000000..8dd0849dc17dd0f8e40d7fc042d01970f807c8b0
--- /dev/null
+++ b/src/UnitTests/Matrices/MatrixWrappingTest.cu
@@ -0,0 +1,11 @@
+/***************************************************************************
+ MatrixWrappingTest.cu - description
+ -------------------
+ begin : Mar 4, 2021
+ copyright : (C) 2021 by Tomas Oberhuber et al.
+ email : tomas.oberhuber@fjfi.cvut.cz
+ ***************************************************************************/
+
+/* See Copyright Notice in tnl/Copyright */
+
+#include "MatrixWrappingTest.h"
diff --git a/src/UnitTests/Matrices/MatrixWrappingTest.h b/src/UnitTests/Matrices/MatrixWrappingTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..af3fb00b3f4181a925b15cb84bbac568d02b1121
--- /dev/null
+++ b/src/UnitTests/Matrices/MatrixWrappingTest.h
@@ -0,0 +1,113 @@
+/***************************************************************************
+ SparseMatrixTest.h - description
+ -------------------
+ begin : Mar 21, 2020
+ copyright : (C) 2020 by Tomas Oberhuber et al.
+ email : tomas.oberhuber@fjfi.cvut.cz
+ ***************************************************************************/
+
+/* See Copyright Notice in tnl/Copyright */
+
+#pragma once
+
+#include <TNL/Containers/Vector.h>
+#include <TNL/Containers/VectorView.h>
+#include <TNL/Math.h>
+#include <TNL/Matrices/DenseMatrix.h>
+#include <TNL/Matrices/SparseMatrix.h>
+#include <TNL/Matrices/MatrixWrapping.h>
+#include <TNL/Algorithms/Segments/Ellpack.h>
+#include <iostream>
+#include <sstream>
+
+#ifdef HAVE_GTEST
+#include <gtest/gtest.h>
+
+template< typename Device_, typename Index_, typename IndexAllocator_ >
+using RowMajorEllpack = TNL::Algorithms::Segments::Ellpack< Device_, Index_, IndexAllocator_, TNL::Algorithms::Segments::RowMajorOrder, 1 >;
+
+// test fixture for typed tests
+template< typename Matrix >
+class MatrixTest : public ::testing::Test
+{
+protected:
+ using MatrixType = Matrix;
+};
+
+
+// types for which MatrixTest is instantiated
+// types for which MatrixTest is instantiated
+using MatrixTypes = ::testing::Types
+<
+ TNL::Matrices::DenseMatrix< int, TNL::Devices::Host, short >,
+ TNL::Matrices::DenseMatrix< long, TNL::Devices::Host, short >,
+ TNL::Matrices::DenseMatrix< float, TNL::Devices::Host, short >,
+ TNL::Matrices::DenseMatrix< double, TNL::Devices::Host, short >,
+ TNL::Matrices::DenseMatrix< int, TNL::Devices::Host, int >,
+ TNL::Matrices::DenseMatrix< long, TNL::Devices::Host, int >,
+ TNL::Matrices::DenseMatrix< float, TNL::Devices::Host, int >,
+ TNL::Matrices::DenseMatrix< double, TNL::Devices::Host, int >,
+ TNL::Matrices::DenseMatrix< int, TNL::Devices::Host, long >,
+ TNL::Matrices::DenseMatrix< long, TNL::Devices::Host, long >,
+ TNL::Matrices::DenseMatrix< float, TNL::Devices::Host, long >,
+ TNL::Matrices::DenseMatrix< double, TNL::Devices::Host, long >
+#ifdef HAVE_CUDA
+ ,TNL::Matrices::DenseMatrix< int, TNL::Devices::Cuda, short >,
+ TNL::Matrices::DenseMatrix< long, TNL::Devices::Cuda, short >,
+ TNL::Matrices::DenseMatrix< float, TNL::Devices::Cuda, short >,
+ TNL::Matrices::DenseMatrix< double, TNL::Devices::Cuda, short >,
+ TNL::Matrices::DenseMatrix< int, TNL::Devices::Cuda, int >,
+ TNL::Matrices::DenseMatrix< long, TNL::Devices::Cuda, int >,
+ TNL::Matrices::DenseMatrix< float, TNL::Devices::Cuda, int >,
+ TNL::Matrices::DenseMatrix< double, TNL::Devices::Cuda, int >,
+ TNL::Matrices::DenseMatrix< int, TNL::Devices::Cuda, long >,
+ TNL::Matrices::DenseMatrix< long, TNL::Devices::Cuda, long >,
+ TNL::Matrices::DenseMatrix< float, TNL::Devices::Cuda, long >,
+ TNL::Matrices::DenseMatrix< double, TNL::Devices::Cuda, long >
+#endif
+>;
+
+
+TYPED_TEST_SUITE( MatrixTest, MatrixTypes);
+
+TYPED_TEST( MatrixTest, WrapMatrix )
+{
+ using DenseMatrix = typename TestFixture::MatrixType;
+ using RealType = typename DenseMatrix::RealType;
+ using DeviceType = typename DenseMatrix::DeviceType;
+ using IndexType = typename DenseMatrix::IndexType;
+ using CSRMatrix = TNL::Matrices::SparseMatrix< RealType, DeviceType, IndexType, TNL::Matrices::GeneralMatrix, TNL::Algorithms::Segments::CSRScalar >;
+ using EllpackMatrix = TNL::Matrices::SparseMatrix< RealType, DeviceType, IndexType, TNL::Matrices::GeneralMatrix, RowMajorEllpack >;
+
+ DenseMatrix denseMatrix{
+ { 1, 2, 0, 0 },
+ { 0, 6, 0, 0 },
+ { 9, 0, 0, 0 },
+ { 0, 0, 15, 16 } };
+ IndexType rows( 4 ), columns( 4 );
+ CSRMatrix csrMatrix;
+ EllpackMatrix ellpackMatrix;
+ csrMatrix = ellpackMatrix = denseMatrix;
+
+ auto denseMatrixValues = denseMatrix.getValues().getData();
+
+ auto csrMatrixValues = csrMatrix.getValues().getData();
+ auto csrMatrixColumnIndexes = csrMatrix.getColumnIndexes().getData();
+ auto csrMatrixRowPointers = csrMatrix.getSegments().getOffsets().getData();
+
+ auto ellpackMatrixValues = ellpackMatrix.getValues().getData();
+ auto ellpackMatrixColumnIndexes = ellpackMatrix.getColumnIndexes().getData();
+
+ auto wrappedDenseMatrix = TNL::Matrices::wrapDenseMatrix< DeviceType >( rows, columns, denseMatrixValues );
+ auto wrappedCSRMatrix = TNL::Matrices::wrapCSRMatrix< DeviceType >( rows, columns, csrMatrixRowPointers, csrMatrixValues, csrMatrixColumnIndexes );
+ auto wrappedEllpackMatrix = TNL::Matrices::wrapEllpackMatrix< DeviceType >( rows, columns, ( IndexType ) 2, ellpackMatrixValues, ellpackMatrixColumnIndexes );
+
+ EXPECT_EQ( denseMatrix, wrappedDenseMatrix );
+ EXPECT_EQ( csrMatrix, wrappedCSRMatrix );
+ EXPECT_EQ( ellpackMatrix, wrappedEllpackMatrix );
+}
+
+
+#include "../main.h"
+
+#endif