Implementing the sparse matrix benchmark. (643690da) · Commits · TNL / tnl-dev

src/implementation/matrices/tnlCSRMatrix_impl.h

+77 −15

Original line number	Diff line number	Diff line
		@@ -88,6 +88,14 @@ bool tnlCSRMatrix< Real, Device, Index >::setRowLengths( const RowLengthsVector&
		return true;
		}

		template< typename Real,
		typename Device,
		typename Index >
		Index tnlCSRMatrix< Real, Device, Index >::getRowLength( const IndexType row ) const
		{
		return this->rowPointers[ row + 1 ] - this->rowPointers[ row ];
		}

		template< typename Real,
		typename Device,
		typename Index >
		@@ -151,21 +159,6 @@ bool tnlCSRMatrix< Real, Device, Index >::setElement( const IndexType row,
		return this->addElement( row, column, value, 0.0 );
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlCSRMatrix< Real, Device, Index >::getElement( const IndexType row,
		const IndexType column ) const
		{
		IndexType elementPtr = this->rowPointers[ row ];
		const IndexType rowEnd = this->rowPointers[ row + 1 ];
		while( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] < column )
		elementPtr++;
		if( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] == column )
		return this->values[ elementPtr ];
		return 0.0;
		}

		template< typename Real,
		typename Device,
		typename Index >
		@@ -214,6 +207,75 @@ bool tnlCSRMatrix< Real, Device, Index >::addElement( const IndexType row,
		return false;
		}

		template< typename Real,
		typename Device,
		typename Index >
		bool tnlCSRMatrix< Real, Device, Index > :: setRow( const IndexType row,
		const IndexType* columnIndexes,
		const RealType* values,
		const IndexType elements )
		{
		IndexType elementPointer = this->rowPointers[ row ];
		const IndexType rowLength = this->rowPointers[ row + 1 ] - elementPointer;
		if( elements > rowLength )
		return false;

		for( IndexType i = 0; i < elements; i++ )
		{
		this->columnIndexes[ elementPointer ] = columnIndexes[ i ];
		this->values[ elementPointer ] = values[ i ];
		elementPointer++;
		}
		for( IndexType i = elements; i < rowLength; i++ )
		this->columnIndexes[ elementPointer++ ] = this->getColumns();
		return true;
		}

		template< typename Real,
		typename Device,
		typename Index >
		bool tnlCSRMatrix< Real, Device, Index > :: addRow( const IndexType row,
		const IndexType* columns,
		const RealType* values,
		const IndexType numberOfElements,
		const RealType& thisElementMultiplicator )
		{
		// TODO: implement
		return false;
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlCSRMatrix< Real, Device, Index >::getElement( const IndexType row,
		const IndexType column ) const
		{
		IndexType elementPtr = this->rowPointers[ row ];
		const IndexType rowEnd = this->rowPointers[ row + 1 ];
		while( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] < column )
		elementPtr++;
		if( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] == column )
		return this->values[ elementPtr ];
		return 0.0;
		}

		template< typename Real,
		typename Device,
		typename Index >
		void tnlCSRMatrix< Real, Device, Index >::getRow( const IndexType row,
		IndexType* columns,
		RealType* values ) const
		{
		IndexType elementPointer = this->rowPointers[ row ];
		const IndexType rowLength = this->rowPointers[ row + 1 ] - elementPointer;
		for( IndexType i = 0; i < rowLength; i++ )
		{
		columns[ i ] = this->columnIndexes[ elementPointer ];
		values[ i ] = this->values[ elementPointer ];
		elementPointer++;
		}
		}

		template< typename Real,
		typename Device,
		typename Index >

src/implementation/matrices/tnlChunkedEllpackMatrix_impl.h

+92 −20

Original line number	Diff line number	Diff line
		@@ -196,6 +196,17 @@ bool tnlChunkedEllpackMatrix< Real, Device, Index >::setRowLengths( const RowLen
		return tnlSparseMatrix< Real, Device, Index >::allocateMatrixElements( elementsToAllocation );
		}

		template< typename Real,
		typename Device,
		typename Index >
		Index tnlChunkedEllpackMatrix< Real, Device, Index >::getRowLength( const IndexType row ) const
		{
		const IndexType& sliceIndex = slicesToRowsMapping[ row ];
		tnlAssert( sliceIndex < this->rows, );
		const IndexType& chunkSize = slices.getElement( sliceIndex ).chunkSize;
		return rowPointers[ row + 1 ] - rowPointers[ row ];
		}

		template< typename Real,
		typename Device,
		typename Index >
		@@ -295,26 +306,6 @@ bool tnlChunkedEllpackMatrix< Real, Device, Index >::setElement( const IndexType
		return this->addElement( row, column, value, 0.0 );
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlChunkedEllpackMatrix< Real, Device, Index >::getElement( const IndexType row,
		const IndexType column ) const
		{
		const IndexType& sliceIndex = slicesToRowsMapping[ row ];
		tnlAssert( sliceIndex < this->rows, );
		const IndexType& chunkSize = slices.getElement( sliceIndex ).chunkSize;
		IndexType elementPtr = rowPointers[ row ];
		const IndexType rowEnd = rowPointers[ row + 1 ];
		tnlAssert( rowEnd <= this->columnIndexes.getSize(),
		cerr << "rowEnd = " << rowEnd << " this->columnIndexes.getSize() = " << this->columnIndexes.getSize() );
		while( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] < column )
		elementPtr++;
		if( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] == column )
		return this->values[ elementPtr ];
		return 0.0;
		}

		template< typename Real,
		typename Device,
		typename Index >
		@@ -372,6 +363,87 @@ bool tnlChunkedEllpackMatrix< Real, Device, Index >::addElement( const IndexType
		return false;
		}

		template< typename Real,
		typename Device,
		typename Index >
		bool tnlChunkedEllpackMatrix< Real, Device, Index > :: setRow( const IndexType row,
		const IndexType* columnIndexes,
		const RealType* values,
		const IndexType elements )
		{
		const IndexType& sliceIndex = slicesToRowsMapping[ row ];
		tnlAssert( sliceIndex < this->rows, );
		const IndexType& chunkSize = slices.getElement( sliceIndex ).chunkSize;
		IndexType elementPointer = rowPointers[ row ];
		const IndexType rowEnd = rowPointers[ row + 1 ];
		if( elements > rowEnd - elementPointer )
		return false;

		for( IndexType i = 0; i < elements; i++ )
		{
		this->columnIndexes[ elementPointer ] = columnIndexes[ i ];
		this->values[ elementPointer ] = values[ i ];
		elementPointer++;
		}
		for( IndexType i = elements; i < this->rowLengths; i++ )
		this->columnIndexes[ elementPointer++ ] = this->getColumns();
		return true;
		}

		template< typename Real,
		typename Device,
		typename Index >
		bool tnlChunkedEllpackMatrix< Real, Device, Index > :: addRow( const IndexType row,
		const IndexType* columns,
		const RealType* values,
		const IndexType numberOfElements,
		const RealType& thisElementMultiplicator )
		{
		// TODO: implement
		return false;
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlChunkedEllpackMatrix< Real, Device, Index >::getElement( const IndexType row,
		const IndexType column ) const
		{
		const IndexType& sliceIndex = slicesToRowsMapping[ row ];
		tnlAssert( sliceIndex < this->rows, );
		const IndexType& chunkSize = slices.getElement( sliceIndex ).chunkSize;
		IndexType elementPtr = rowPointers[ row ];
		const IndexType rowEnd = rowPointers[ row + 1 ];
		tnlAssert( rowEnd <= this->columnIndexes.getSize(),
		cerr << "rowEnd = " << rowEnd << " this->columnIndexes.getSize() = " << this->columnIndexes.getSize() );
		while( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] < column )
		elementPtr++;
		if( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] == column )
		return this->values[ elementPtr ];
		return 0.0;
		}

		template< typename Real,
		typename Device,
		typename Index >
		void tnlChunkedEllpackMatrix< Real, Device, Index >::getRow( const IndexType row,
		IndexType* columns,
		RealType* values ) const
		{
		const IndexType& sliceIndex = slicesToRowsMapping[ row ];
		tnlAssert( sliceIndex < this->rows, );
		const IndexType& chunkSize = slices.getElement( sliceIndex ).chunkSize;
		IndexType elementPointer = rowPointers[ row ];
		const IndexType rowLength = rowPointers[ row + 1 ] - elementPointer;

		for( IndexType i = 0; i < rowLength; i++ )
		{
		columns[ i ] = this->columnIndexes[ elementPointer ];
		values[ i ] = this->values[ elementPointer ];
		elementPointer++;
		}
		}

		template< typename Real,
		typename Device,
		typename Index >

src/implementation/matrices/tnlDenseMatrix_impl.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -82,7 +82,7 @@ bool tnlDenseMatrix< Real, Device, Index >::setRowLengths( const RowLengthsVecto
		template< typename Real,
		typename Device,
		typename Index >
		IndexType tnlDenseMatrix< Real, Device, Index >::getRowLength( const IndexType row ) const
		Index tnlDenseMatrix< Real, Device, Index >::getRowLength( const IndexType row ) const
		{
		return this->getColumns();
		}

src/implementation/matrices/tnlEllpackMatrix_impl.h

+72 −14

Original line number	Diff line number	Diff line
		@@ -94,6 +94,14 @@ bool tnlEllpackMatrix< Real, Device, Index >::setConstantRowLengths( const Index
		return true;
		}

		template< typename Real,
		typename Device,
		typename Index >
		Index tnlEllpackMatrix< Real, Device, Index >::getRowLength( const IndexType row ) const
		{
		return this->rowLengths;
		}

		template< typename Real,
		typename Device,
		typename Index >
		@@ -157,20 +165,6 @@ bool tnlEllpackMatrix< Real, Device, Index > :: setElement( const IndexType row,
		return this->addElement( row, column, value, 0.0 );
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlEllpackMatrix< Real, Device, Index >::getElement( const IndexType row,
		const IndexType column ) const
		{
		IndexType elementPtr( row * this->rowLengths );
		const IndexType rowEnd( elementPtr + this->rowLengths );
		while( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] < column ) elementPtr++;
		if( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] == column )
		return this->values.getElement( elementPtr );
		return 0.0;
		}

		template< typename Real,
		typename Device,
		typename Index >
		@@ -218,6 +212,70 @@ bool tnlEllpackMatrix< Real, Device, Index > :: addElement( const IndexType row,
		return false;
		}

		template< typename Real,
		typename Device,
		typename Index >
		bool tnlEllpackMatrix< Real, Device, Index > :: setRow( const IndexType row,
		const IndexType* columnIndexes,
		const RealType* values,
		const IndexType elements )
		{
		if( elements > this->rowLengths )
		return false;
		IndexType elementPointer( row * this->rowLengths );
		for( IndexType i = 0; i < elements; i++ )
		{
		this->columnIndexes[ elementPointer ] = columnIndexes[ i ];
		this->values[ elementPointer ] = values[ i ];
		elementPointer++;
		}
		for( IndexType i = elements; i < this->rowLengths; i++ )
		this->columnIndexes[ elementPointer++ ] = this->getColumns();
		return true;
		}

		template< typename Real,
		typename Device,
		typename Index >
		bool tnlEllpackMatrix< Real, Device, Index > :: addRow( const IndexType row,
		const IndexType* columns,
		const RealType* values,
		const IndexType numberOfElements,
		const RealType& thisElementMultiplicator )
		{
		// TODO: implement
		return false;
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlEllpackMatrix< Real, Device, Index >::getElement( const IndexType row,
		const IndexType column ) const
		{
		IndexType elementPtr( row * this->rowLengths );
		const IndexType rowEnd( elementPtr + this->rowLengths );
		while( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] < column ) elementPtr++;
		if( elementPtr < rowEnd && this->columnIndexes[ elementPtr ] == column )
		return this->values.getElement( elementPtr );
		return 0.0;
		}

		template< typename Real,
		typename Device,
		typename Index >
		void tnlEllpackMatrix< Real, Device, Index >::getRow( const IndexType row,
		IndexType* columns,
		RealType* values ) const
		{
		IndexType elementPtr( row * this->rowLengths );
		for( IndexType i = 0; i < this->rowLengths; i++ )
		{
		columns[ i ] = this->columnIndexes[ elementPtr ];
		values[ i ] = this->values[ elementPtr ];
		elementPtr++;
		}
		}

		template< typename Real,
		typename Device,

src/implementation/matrices/tnlMultidiagonalMatrix_impl.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -83,7 +83,7 @@ bool tnlMultidiagonalMatrix< Real, Device, Index >::setRowLengths( const RowLeng
		template< typename Real,
		typename Device,
		typename Index >
		IndexType tnlMultidiagonalMatrix< Real, Device, Index >::getRowLength( const IndexType row ) const
		Index tnlMultidiagonalMatrix< Real, Device, Index >::getRowLength( const IndexType row ) const
		{
		IndexType rowLength( 0 );
		for( IndexType i = 0; i < diagonalsShift.getSize(); i++ )