Added TridiagonalMatrixView.

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

                          Tridiagonal.h  -  description

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

    begin                : Nov 30, 2013

    copyright            : (C) 2013 by Tomas Oberhuber

    email                : tomas.oberhuber@fjfi.cvut.cz

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

/* See Copyright Notice in tnl/Copyright */

#pragma once

#include <TNL/Matrices/Matrix.h>

#include <TNL/Containers/Vector.h>

#include <TNL/Matrices/TridiagonalRow.h>

namespace TNL {

namespace Matrices {   

template< typename Device >

class TridiagonalDeviceDependentCode;

template< typename Real = double,

          typename Device = Devices::Host,

          typename Index = int >

class Tridiagonal : public Matrix< 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 Tridiagonal;

public:

   typedef Real RealType;

   typedef Device DeviceType;

   typedef Index IndexType;

   typedef typename Matrix< Real, Device, Index >::CompressedRowLengthsVector CompressedRowLengthsVector;

   typedef typename Matrix< Real, Device, Index >::ConstCompressedRowLengthsVectorView ConstCompressedRowLengthsVectorView;

   typedef Matrix< Real, Device, Index > BaseType;

   typedef TridiagonalRow< Real, Index > MatrixRow;

   template< typename _Real = Real,

             typename _Device = Device,

             typename _Index = Index >

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

   Tridiagonal();

   static String getSerializationType();

   virtual String getSerializationTypeVirtual() const;

   void setDimensions( const IndexType rows,

                       const IndexType columns );

   void setCompressedRowLengths( ConstCompressedRowLengthsVectorView rowLengths );

   IndexType getRowLength( const IndexType row ) const;

   __cuda_callable__

   IndexType getRowLengthFast( const IndexType row ) const;

   IndexType getMaxRowLength() const;

   template< typename Real2, typename Device2, typename Index2 >

   void setLike( const Tridiagonal< Real2, Device2, Index2 >& m );

   IndexType getNumberOfMatrixElements() const;

   IndexType getNumberOfNonzeroMatrixElements() const;

   IndexType getMaxRowlength() const;

   void reset();

   template< typename Real2, typename Device2, typename Index2 >

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

   template< typename Real2, typename Device2, typename Index2 >

   bool operator != ( const Tridiagonal< Real2, Device2, Index2 >& matrix ) const;

   void setValue( const RealType& v );

   __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__

   RealType getElementFast( const IndexType row,

                            const IndexType column ) const;

   RealType getElement( const IndexType row,

                        const IndexType column ) const;

   __cuda_callable__

   void getRowFast( const IndexType row,

                    IndexType* columns,

                    RealType* values ) const;

   __cuda_callable__

   MatrixRow getRow( const IndexType rowIndex );

   __cuda_callable__

   const MatrixRow getRow( const IndexType rowIndex ) const;

   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 Real2, typename Index2 >

   void addMatrix( const Tridiagonal< Real2, Device, Index2 >& matrix,

                   const RealType& matrixMultiplicator = 1.0,

                   const RealType& thisMatrixMultiplicator = 1.0 );

   template< typename Real2, typename Index2 >

   void getTransposition( const Tridiagonal< Real2, Device, Index2 >& matrix,

                          const RealType& matrixMultiplicator = 1.0 );

   template< typename Vector1, typename Vector2 >

   __cuda_callable__

   void performSORIteration( const Vector1& b,

                             const IndexType row,

                             Vector2& x,

                             const RealType& omega = 1.0 ) const;

   // copy assignment

   Tridiagonal& operator=( const Tridiagonal& matrix );

   // cross-device copy assignment

   template< typename Real2, typename Device2, typename Index2,

             typename = typename Enabler< Device2 >::type >

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

   void save( File& file ) const;

   void load( File& file );

   void save( const String& fileName ) const;

   void load( const String& fileName );

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

protected:

   __cuda_callable__

   IndexType getElementIndex( const IndexType row,

                              const IndexType column ) const;

   Containers::Vector< RealType, DeviceType, IndexType > values;

   typedef TridiagonalDeviceDependentCode< DeviceType > DeviceDependentCode;

   friend class TridiagonalDeviceDependentCode< DeviceType >;

};

} // namespace Matrices

} // namespace TNL

#include <TNL/Matrices/Tridiagonal_impl.h>