Commit 8758a8e6 authored by Tomáš Oberhuber's avatar Tomáš Oberhuber Committed by Tomáš Oberhuber
Browse files

Deleting of deprecated methods in dense matrix.

parent 25d43763

src/TNL/Matrices/Dense.h

+0 −48
Original line number Diff line number Diff line
@@ -90,66 +90,18 @@ public: 
   const Real& operator()( const IndexType row,

                           const IndexType column ) const;



   __cuda_callable__

   bool setElementFast( const IndexType row,

                        const IndexType column,

                        const RealType& value );



   bool setElement( const IndexType row,

                    const IndexType column,

                    const RealType& value );



   __cuda_callable__

   bool addElementFast( const IndexType row,

                        const IndexType column,

                        const RealType& value,

                        const RealType& thisElementMultiplicator = 1.0 );



   bool addElement( const IndexType row,

                    const IndexType column,

                    const RealType& value,

                    const RealType& thisElementMultiplicator = 1.0 );



   __cuda_callable__

   bool setRowFast( const IndexType row,

                    const IndexType* columns,

                    const RealType* values,

                    const IndexType elements );



   bool setRow( const IndexType row,

                const IndexType* columns,

                const RealType* values,

                const IndexType elements );



   __cuda_callable__

   bool addRowFast( const IndexType row,

                    const IndexType* columns,

                    const RealType* values,

                    const IndexType elements,

                    const RealType& thisRowMultiplicator = 1.0 );



   bool addRow( const IndexType row,

                const IndexType* columns,

                const RealType* values,

                const IndexType elements,

                const RealType& thisRowMultiplicator = 1.0 );



   __cuda_callable__

   const Real& getElementFast( const IndexType row,

                               const IndexType column ) const;



   Real getElement( const IndexType row,

                    const IndexType column ) const;



   __cuda_callable__

   void getRowFast( const IndexType row,

                    IndexType* columns,

                    RealType* values ) const;



   /*void getRow( const IndexType row,

                IndexType* columns,

                RealType* values ) const;*/



   __cuda_callable__

   MatrixRow getRow( const IndexType rowIndex );

src/TNL/Matrices/Dense.hpp

+6 −167
Original line number Diff line number Diff line
@@ -145,7 +145,6 @@ template< typename Real, 
void Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::reset()

{

   Matrix< Real, Device, Index >::reset();

   this->values.reset();

}



template< typename Real,
@@ -155,10 +154,9 @@ template< typename Real, 
          typename RealAllocator >

void Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::setValue( const Real& value )

{

   this->values.setValue( value );

   this->values = value;

}





template< typename Real,

          typename Device,

          typename Index,
@@ -193,26 +191,6 @@ const Real& Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::operator 
   return this->values.operator[]( this->getElementIndex( row, column ) );

}





template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          typename RealAllocator >

__cuda_callable__

bool Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::setElementFast( const IndexType row,

                                                            const IndexType column,

                                                            const RealType& value )

{

   TNL_ASSERT_GE( row, 0, "Row index must be non-negative." );

   TNL_ASSERT_LT( row, this->getRows(), "Row index is out of bounds." );

   TNL_ASSERT_GE( column, 0, "Column index must be non-negative." );

   TNL_ASSERT_LT( column, this->getColumns(), "Column index is out of bounds." );



   this->values.operator[]( this->getElementIndex( row, column ) ) = value;

   return true;

}



template< typename Real,

          typename Device,

          typename Index,
@@ -226,32 +204,6 @@ bool Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::setElement( con 
   return true;

}





template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          typename RealAllocator >

__cuda_callable__

bool Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::addElementFast( const IndexType row,

                                                   const IndexType column,

                                                   const RealType& value,

                                                   const RealType& thisElementMultiplicator )

{

   TNL_ASSERT_GE( row, 0, "Row index must be non-negative." );

   TNL_ASSERT_LT( row, this->getRows(), "Row index is out of bounds." );

   TNL_ASSERT_GE( column, 0, "Column index must be non-negative." );

   TNL_ASSERT_LT( column, this->getColumns(), "Column index is out of bounds." );



   const IndexType elementIndex = this->getElementIndex( row, column );

   if( thisElementMultiplicator == 1.0 )

      this->values.operator[]( elementIndex ) += value;

   else

      this->values.operator[]( elementIndex ) =

         thisElementMultiplicator * this->values.operator[]( elementIndex ) + value;

   return true;

}



template< typename Real,

          typename Device,

          typename Index,
@@ -272,103 +224,6 @@ bool Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::addElement( con 
   return true;

}





template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          typename RealAllocator >

__cuda_callable__

bool Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::setRowFast( const IndexType row,

                                                        const IndexType* columns,

                                                        const RealType* values,

                                                        const IndexType elements )

{

   TNL_ASSERT( elements <= this->getColumns(),

            std::cerr << " elements = " << elements

                 << " this->columns = " << this->getColumns() );

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

      this->setElementFast( row, columns[ i ], values[ i ] );

   return true;

}



template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          typename RealAllocator >

bool Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::setRow( const IndexType row,

                                                    const IndexType* columns,

                                                    const RealType* values,

                                                    const IndexType elements )

{

   TNL_ASSERT( elements <= this->getColumns(),

            std::cerr << " elements = " << elements

                 << " this->columns = " << this->getColumns() );

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

      this->setElement( row, columns[ i ], values[ i ] );

   return true;

}



template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          typename RealAllocator >

__cuda_callable__

bool Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::addRowFast( const IndexType row,

                                                        const IndexType* columns,

                                                        const RealType* values,

                                                        const IndexType elements,

                                                        const RealType& thisRowMultiplicator )

{

   TNL_ASSERT( elements <= this->columns,

            std::cerr << " elements = " << elements

                 << " this->columns = " << this->columns );

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

      this->setElementFast( row, columns[ i ],

                            thisRowMultiplicator * this->getElementFast( row, columns[ i ] ) + values[ i ] );

   return true;

}



template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          typename RealAllocator >

bool Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::addRow( const IndexType row,

                                                    const IndexType* columns,

                                                    const RealType* values,

                                                    const IndexType elements,

                                                    const RealType& thisRowMultiplicator )

{

   TNL_ASSERT( elements <= this->columns,

            std::cerr << " elements = " << elements

                 << " this->columns = " << this->columns );

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

      this->setElement( row, columns[ i ],

                        thisRowMultiplicator * this->getElement( row, columns[ i ] ) + values[ i ] );

   return true;

}





template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          typename RealAllocator >

__cuda_callable__

const Real& Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::getElementFast( const IndexType row,

                                                          const IndexType column ) const

{

   TNL_ASSERT_GE( row, 0, "Row index must be non-negative." );

   TNL_ASSERT_LT( row, this->getRows(), "Row index is out of bounds." );

   TNL_ASSERT_GE( column, 0, "Column index must be non-negative." );

   TNL_ASSERT_LT( column, this->getColumns(), "Column index is out of bounds." );



   return this->values.operator[]( this->getElementIndex( row, column ) );

}



template< typename Real,

          typename Device,

          typename Index,
@@ -380,23 +235,6 @@ Real Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::getElement( con 
   return this->values.getElement( this->getElementIndex( row, column ) );

}



template< typename Real,

          typename Device,

          typename Index,

          bool RowMajorOrder,

          typename RealAllocator >

__cuda_callable__

void Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::getRowFast( const IndexType row,

                                                        IndexType* columns,

                                                        RealType* values ) const

{

   for( IndexType i = 0; i < this->getColumns(); i++ )

   {

      columns[ i ] = i;

      values[ i ] = this->getElementFast( row, i );

   }

}



template< typename Real,

          typename Device,

          typename Index,
@@ -448,8 +286,9 @@ typename Vector::RealType Dense< Real, Device, Index, RowMajorOrder, RealAllocat 
                                                                                   const Vector& vector ) const

{

   RealType sum( 0.0 );

   for( IndexType column = 0; column < this->getColumns(); column++ )

      sum += this->getElementFast( row, column ) * vector[ column ];

   // TODO: Fix this

   //for( IndexType column = 0; column < this->getColumns(); column++ )

   //   sum += this->getElementFast( row, column ) * vector[ column ];

   return sum;

}
@@ -949,9 +788,9 @@ void Dense< Real, Device, Index, RowMajorOrder, RealAllocator >::performSORItera 
   for( IndexType i = 0; i < this->getColumns(); i++ )

   {

      if( i == row )

         diagonalValue = this->getElementFast( row, row );

         diagonalValue = this->getElement( row, row );

      else

         sum += this->getElementFast( row, i ) * x[ i ];

         sum += this->getElement( row, i ) * x[ i ];

   }

   x[ row ] = ( 1.0 - omega ) * x[ row ] + omega / diagonalValue * ( b[ row ] - sum );

}

src/TNL/Matrices/DistributedSpMV.h

+2 −2
Original line number Diff line number Diff line
@@ -125,8 +125,8 @@ public: 
      preCommPatternEnds.setLike( commPatternEnds );

      for( int j = 0; j < nproc; j++ )

      for( int i = 0; i < nproc; i++ ) {

         preCommPatternStarts.setElementFast( j, i, span_starts.getElement( i ) );

         preCommPatternEnds.setElementFast( j, i, span_ends.getElement( i ) );

         preCommPatternStarts.setElement( j, i, span_starts.getElement( i ) );

         preCommPatternEnds.setElement( j, i, span_ends.getElement( i ) );

      }



      // assemble the commPattern* matrices

src/UnitTests/Matrices/DenseMatrixTest.h

+6 −4
Original line number Diff line number Diff line
@@ -537,9 +537,10 @@ void test_SetRow() 
    IndexType row = 0;

    IndexType elements = 5;

    

    m.setRow( row++, colIndexes1, row1, elements );

    // TODO: Fix this

    /*m.setRow( row++, colIndexes1, row1, elements );

    m.setRow( row++, colIndexes2, row2, elements );

    m.setRow( row++, colIndexes3, row3, elements );

    m.setRow( row++, colIndexes3, row3, elements );*/

    

    EXPECT_EQ( m.getElement( 0, 0 ), 11 );

    EXPECT_EQ( m.getElement( 0, 1 ), 11 );
@@ -654,12 +655,13 @@ void test_AddRow() 
    IndexType elements = 5;

    RealType thisRowMultiplicator = 0;

    

    m.addRow( row++, colIndexes0, row0, elements, thisRowMultiplicator++ );

    // TODO: Fix this

    /*m.addRow( row++, colIndexes0, row0, elements, thisRowMultiplicator++ );

    m.addRow( row++, colIndexes1, row1, elements, thisRowMultiplicator++ );

    m.addRow( row++, colIndexes2, row2, elements, thisRowMultiplicator++ );

    m.addRow( row++, colIndexes3, row3, elements, thisRowMultiplicator++ );

    m.addRow( row++, colIndexes4, row4, elements, thisRowMultiplicator++ );

    m.addRow( row++, colIndexes5, row5, elements, thisRowMultiplicator++ );

    m.addRow( row++, colIndexes5, row5, elements, thisRowMultiplicator++ );*/

    

    EXPECT_EQ( m.getElement( 0, 0 ),  11 );

    EXPECT_EQ( m.getElement( 0, 1 ),  11 );