Commit 7049c029 authored by Tomáš Oberhuber's avatar Tomáš Oberhuber
Browse files

Added DenseMatrixView.

parent 5043ac64

src/TNL/Matrices/Dense.h

+7 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
#include <TNL/Devices/Host.h>

#include <TNL/Matrices/DenseMatrixRowView.h>

#include <TNL/Matrices/Matrix.h>

#include <TNL/Matrices/DenseMatrixView.h>

#include <TNL/Containers/Segments/Ellpack.h>



namespace TNL {
@@ -47,6 +48,8 @@ class Dense : public Matrix< Real, Device, Index > 
      using ValuesViewType = typename ValuesType::ViewType;

      using SegmentsType = Containers::Segments::Ellpack< DeviceType, IndexType, typename Allocators::Default< Device >::template Allocator< IndexType >, RowMajorOrder, 1 >;

      using SegmentViewType = typename SegmentsType::SegmentViewType;

      using ViewType = DenseMatrixView< Real, Device, Index, MatrixType, SegmentsViewTemplate >;

      using ConstViewType = DenseMatrixView< typename std::add_const< Real >::type, Device, Index, MatrixType, SegmentsViewTemplate >;

      using RowView = DenseMatrixRowView< SegmentViewType, ValuesViewType >;



      // TODO: remove this
@@ -62,6 +65,10 @@ class Dense : public Matrix< Real, Device, Index > 


      Dense( const IndexType rows, const IndexType columns );

      

      ViewType getView();



      ConstViewType getConstView() const;



      static String getSerializationType();



      virtual String getSerializationTypeVirtual() const;

src/TNL/Matrices/Dense.hpp

+33 −1
Original line number Diff line number Diff line 
/***************************************************************************

                          Dense_impl.h  -  description

                          Dense.hpp  -  description

                             -------------------

    begin                : Nov 29, 2013

    copyright            : (C) 2013 by Tomas Oberhuber
@@ -37,6 +37,38 @@ Dense( const IndexType rows, const IndexType columns ) 
   this->setDimensions( rows, columns );

}



template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          template< typename, typename, typename > class Segments,

          typename RealAllocator >

auto

Dense< Real, Device, Index, RowMajorOrder, Segments, RealAllocator >::

getView() -> ViewType

{

   return ViewType( this->getRows(), 

                    this->getColumns(),

                    this->getValues().getView(),

                    this->segments.getView() );

}



template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          template< typename, typename, typename > class Segments,

          typename RealAllocator >

auto

Dense< Real, Device, Index, RowMajorOrder, Segments, RealAllocator >::

getConstView() const -> ConstViewType

{

   return ConstViewType( this->getRows(),

                         this->getColumns(),

                         this->getValues().getConstView(),

                         this->segments.getConstView() );

}



template< typename Real,

          typename Device,

          typename Index,

src/TNL/Matrices/DenseMatrixView.h

0 → 100644
+207 −0
Original line number Diff line number Diff line 
/***************************************************************************

                          DenseMatrixView.h  -  description

                             -------------------

    begin                : Nov 29, 2013

    copyright            : (C) 2013 by Tomas Oberhuber

    email                : tomas.oberhuber@fjfi.cvut.cz

 ***************************************************************************/



/* See Copyright Notice in tnl/Copyright */



#pragma once



#include <TNL/Allocators/Default.h>

#include <TNL/Devices/Host.h>

#include <TNL/Matrices/DenseMatrixRowView.h>

#include <TNL/Matrices/MatrixView.h>

#include <TNL/Containers/Segments/EllpackView.h>



namespace TNL {

namespace Matrices {



//template< typename Device >

//class DenseDeviceDependentCode;



template< typename Real = double,

          typename Device = Devices::Host,

          typename Index = int,

          bool RowMajorOrder = std::is_same< Device, Devices::Host >::value >

class DenseMatrixView : public MatrixView< Real, Device, Index >

{

   private:

      // convenient template alias for controlling the selection of copy-assignment operator

      template< typename Device2 >

      using Enabler = std::enable_if< ! std::is_same< Device2, Device >::value >;



      // friend class will be needed for templated assignment operators

      //template< typename Real2, typename Device2, typename Index2 >

      //friend class Dense;



   public:

      using RealType = Real;

      using DeviceType = Device;

      using IndexType = Index;

      using BaseType = Matrix< Real, Device, Index >;

      using ValuesType = typename BaseType::ValuesVector;

      using ValuesViewType = typename ValuesType::ViewType;

      using SegmentsType = Containers::Segments::Ellpack< DeviceType, IndexType, typename Allocators::Default< Device >::template Allocator< IndexType >, RowMajorOrder, 1 >;

      using SegmentsViewType = typename SegmentsType::ViewType;

      using SegmentViewType = typename SegmentsType::SegmentViewType;

      using RowView = DenseMatrixRowView< SegmentViewType, ValuesViewType >;



      // TODO: remove this

      using CompressedRowLengthsVector = typename Matrix< Real, Device, Index >::CompressedRowLengthsVector;

      using ConstCompressedRowLengthsVectorView = typename Matrix< RealType, DeviceType, IndexType >::ConstCompressedRowLengthsVectorView;



      template< typename _Real = Real,

                typename _Device = Device,

                typename _Index = Index >

      using Self = Dense< _Real, _Device, _Index >;



      __cuda_callable__

      DenseMatrixView();



      __cuda_callable__

      DenseMatrixView( const IndexType rows,

                       const IndexType columns,

                       const ValuesViewType& values,

                       const SegmentsViewType& segments );



      __cuda_callable__

      DenseMatrixView( const DenseMatrixView& m ) = default;



      __cuda_callable__

      ViewType getView();



      __cuda_callable__

      ConstViewType getConstView() const;



      static String getSerializationType();



      virtual String getSerializationTypeVirtual() const;



      template< typename Vector >

      void getCompressedRowLengths( Vector& rowLengths ) const;



      [[deprecated]]

      IndexType getRowLength( const IndexType row ) const;



      IndexType getMaxRowLength() const;



      IndexType getNumberOfMatrixElements() const;



      IndexType getNumberOfNonzeroMatrixElements() const;



      void reset();



      __cuda_callable__

      const RowView getRow( const IndexType& rowIdx ) const;



      __cuda_callable__

      RowView getRow( const IndexType& rowIdx );





      void setValue( const RealType& v );



      __cuda_callable__

      Real& operator()( const IndexType row,

                        const IndexType column );



      __cuda_callable__

      const Real& operator()( const IndexType row,

                              const IndexType column ) const;



      bool setElement( const IndexType row,

                       const IndexType column,

                       const RealType& value );



      bool addElement( const IndexType row,

                       const IndexType column,

                       const RealType& value,

                       const RealType& thisElementMultiplicator = 1.0 );



      Real getElement( const IndexType row,

                       const IndexType column ) const;



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

      void rowsReduction( IndexType first, IndexType last, Fetch& fetch, Reduce& reduce, Keep& keep, const FetchReal& zero ) const;



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

      void allRowsReduction( Fetch& fetch, Reduce& reduce, Keep& keep, const FetchReal& zero ) const;



      template< typename Function >

      void forRows( IndexType first, IndexType last, Function& function ) const;



      template< typename Function >

      void forRows( IndexType first, IndexType last, Function& function );



      template< typename Function >

      void forAllRows( Function& function ) const;



      template< typename Function >

      void forAllRows( Function& function );



      template< typename Vector >

      __cuda_callable__

      typename Vector::RealType rowVectorProduct( const IndexType row,

                                                  const Vector& vector ) const;



      template< typename InVector, typename OutVector >

      void vectorProduct( const InVector& inVector,

                          OutVector& outVector ) const;



      template< typename Matrix >

      void addMatrix( const Matrix& matrix,

                      const RealType& matrixMultiplicator = 1.0,

                      const RealType& thisMatrixMultiplicator = 1.0 );



      template< typename Matrix1, typename Matrix2, int tileDim = 32 >

      void getMatrixProduct( const Matrix1& matrix1,

                          const Matrix2& matrix2,

                          const RealType& matrix1Multiplicator = 1.0,

                          const RealType& matrix2Multiplicator = 1.0 );



      template< typename Matrix, int tileDim = 32 >

      void getTransposition( const Matrix& matrix,

                             const RealType& matrixMultiplicator = 1.0 );



      template< typename Vector1, typename Vector2 >

      void performSORIteration( const Vector1& b,

                                const IndexType row,

                                Vector2& x,

                                const RealType& omega = 1.0 ) const;



      // copy assignment

      Dense& operator=( const Dense& matrix );



      // cross-device copy assignment

      template< typename Real2, typename Device2, typename Index2,

                typename = typename Enabler< Device2 >::type >

      Dense& operator=( const Dense< Real2, Device2, Index2 >& matrix );



      void save( const String& fileName ) const;



      void load( const String& fileName );



      void save( File& file ) const;



      void load( File& file );



      void print( std::ostream& str ) const;



   protected:



      __cuda_callable__

      IndexType getElementIndex( const IndexType row,

                                 const IndexType column ) const;



      typedef DenseDeviceDependentCode< DeviceType > DeviceDependentCode;

      friend class DenseDeviceDependentCode< DeviceType >;



      SegmentsViewType segments;

};



} // namespace Matrices

} // namespace TNL



#include <TNL/Matrices/DenseMatrixView.hpp>

src/TNL/Matrices/DenseMatrixView.hpp

0 → 100644
+1068 −0

File added.

Preview size limit exceeded, changes collapsed.

src/UnitTests/Matrices/DenseMatrixTest.h

+2 −2
Original line number Diff line number Diff line
@@ -597,8 +597,8 @@ void test_SetRow() 
         { 0, 1, 2, 3, 4 },

         { 2, 3, 4, 5, 6 } };

      auto row = m_ptr->getRow( rowIdx );

      for( IndexType i = 0; i < 5; i++ )

      /   row.setElement( rowIdx, i ); //columnIndexes[ rowIdx ][ i ], values[ rowIdx ][ i ] );

      //for( IndexType i = 0; i < 5; i++ )

      ///   row.setElement( rowIdx, i ); //columnIndexes[ rowIdx ][ i ], values[ rowIdx ][ i ] );

   };

   TNL::Pointers::synchronizeSmartPointersOnDevice< DeviceType >();

   TNL::Algorithms::ParallelFor< DeviceType >::exec( 0, 3, f );