parallel_vector.hpp

Go to the documentation of this file.

#ifndef PARGEMSLR_PARALLEL_VECTOR_H
#define PARGEMSLR_PARALLEL_VECTOR_H
 
#include <iostream>
 
#include "../utils/utils.hpp"
#include "vector.hpp"
#include "int_vector.hpp"
#include "sequential_vector.hpp"
#include "../matrices/parallel_csr_matrix.hpp"
 
namespace pargemslr
{
   
   template <typename T>
   class ParallelVectorClass: public VectorClass<T>
   {
   private:
      
      SequentialVectorClass<T>   _data_vec;
      
      long int                   _n_start;
      
      long int                   _n_global;
      
   public:
      
      ParallelVectorClass();
      
      ParallelVectorClass(const ParallelVectorClass<T> &vec);
      
      ParallelVectorClass( ParallelVectorClass<T> &&vec);
      
      ParallelVectorClass<T>& operator= (const ParallelVectorClass<T> &vec);
      
      ParallelVectorClass<T>& operator= ( ParallelVectorClass<T> &&vec);
      
      virtual ~ParallelVectorClass();
      
      int            Setup(int n_local, parallel_log &parlog);
      
      int            Setup(int n_local, bool setzero, parallel_log &parlog);
      
      int            Setup(int n_local, int location, bool setzero, parallel_log &parlog);
      
      int            Setup(int n_local, int reserve, int location, bool setzero, parallel_log &parlog);
      
      int            Setup(int n_local, long int n_start, long int n_global, parallel_log &parlog);
      
      int            Setup(int n_local, long int n_start, long int n_global, bool setzero, parallel_log &parlog);
      
      int            Setup(int n_local, long int n_start, long int n_global, int location, bool setzero, parallel_log &parlog);
      
      int            Setup(int n_local, long int n_start, long int n_global, int reserve, int location, bool setzero, parallel_log &parlog);
      
      int            SetupPtrStr( ParallelVectorClass<T> &x);
      
      int            SetupPtrStr( ParallelCsrMatrixClass<T> &A);
      
      int            UpdatePtr( void* data, int location);
      
      virtual T&     operator[] (int i);
      
      virtual int    Clear();
      
      virtual T*     GetData() const;
 
      SequentialVectorClass<T>&  GetDataVector();
 
      virtual int    GetDataLocation() const;
      
      virtual int    GetLengthLocal() const;
      
      virtual long int GetLengthGlobal() const;
      
      virtual long int GetStartGlobal() const;
      
      bool           IsHoldingData() const;
      
      int            SetHoldingData(bool hold_data);
      
      int            Plot( int conditiona, int conditionb, int width);
      
      int            WriteToDisk( const char *datafilename);
      
      virtual int    Fill(const T &v);
      
      virtual int    Rand();
      
      virtual int    Scale( const T &alpha);
      
      virtual int    Axpy( const T &alpha, const VectorClass<T> &x);
      
      virtual int    Axpy( const T &alpha, const VectorClass<T> &x, VectorClass<T> &y);
      
      virtual int    Axpy( const T &alpha, const VectorClass<T> &x, const T &beta, VectorClass<T> &y);
      
      virtual int    Norm2( float &norm) const;
      
      virtual int    Norm2( double &norm) const;
            
      virtual int    NormInf( float &norm);
      
      virtual int    NormInf( double &norm);
      
      virtual int    Dot( const VectorClass<T> &y, T &t) const;
      
      virtual bool   IsParallel() const;
 
#ifdef PARGEMSLR_CUDA 
#if (PARGEMSLR_CUDA_VERSION == 11)
 
      virtual cusparseDnVecDescr_t  GetCusparseVec() const;
      
      int            SetCusparseVec(cusparseDnVecDescr_t cusparse_vec);
#endif
#endif
 
      virtual int    MoveData( const int &location);
      
      int            ReadFromSingleMMFile(const char *vecfile, int idxin);
      
   };
   
   typedef ParallelVectorClass<float>     vector_par_float;
   typedef ParallelVectorClass<double>    vector_par_double;
   typedef ParallelVectorClass<complexs>  vector_par_complexs;
   typedef ParallelVectorClass<complexd>  vector_par_complexd;
   template<> struct PargemslrIsComplex<ParallelVectorClass<complexs> > : public std::true_type {};
   template<> struct PargemslrIsComplex<ParallelVectorClass<complexd> > : public std::true_type {};
   template<> struct PargemslrIsParallel<ParallelVectorClass<complexs> > : public std::true_type {};
   template<> struct PargemslrIsParallel<ParallelVectorClass<complexd> > : public std::true_type {};
   
}
 
#endif