sequential_vector.hpp

Go to the documentation of this file.

#ifndef PARGEMSLR_SEQUENTIAL_VECTOR_H
#define PARGEMSLR_SEQUENTIAL_VECTOR_H
 
#include <iostream>
 
#include "../utils/utils.hpp"
#include "../utils/structs.hpp"
#include "vector.hpp"
#include "int_vector.hpp"
 
#ifdef PARGEMSLR_CUDA
#include "cusparse.h"
#endif
 
namespace pargemslr
{
   template <typename T> class CsrMatrixClass;
   
   template <typename T>
   class SequentialVectorClass: public VectorClass<T>
   {
   private:
      
      /* variables */
#ifdef PARGEMSLR_CUDA 
#if (PARGEMSLR_CUDA_VERSION == 11)
 
      cusparseDnVecDescr_t          _cusparse_vec;
#endif
#endif
      
      T*             _data;
      
      int            _length;
      
      int            _maxlength;
      
      bool           _hold_data;
      
      int            _location;
      
   public:
      
      SequentialVectorClass();
      
      SequentialVectorClass(const SequentialVectorClass<T> &vec);
      
      SequentialVectorClass(SequentialVectorClass<T>&& vec);
      
      SequentialVectorClass<T>& operator= (const SequentialVectorClass<T> &vec);
      
      SequentialVectorClass<T>& operator= (SequentialVectorClass<T>&& vec);
      
      virtual ~SequentialVectorClass();
      
      int            Setup(int length);
      
      int            Setup(int length, bool setzero);
      
      int            Setup(int length, int location, bool setzero);
      
      int            Setup(int length, int reserve, int location, bool setzero);
      
      int            SetupPtrStr( SequentialVectorClass<T> &x);
      
      int            SetupPtrStr( CsrMatrixClass<T> &A);
      
      int            SetupPtrStr( int length);
      
      int            UpdatePtr( void* data, int location);
      
      int            SetupPtr( void* data, int length, int location);
      
      int            SetupPtr( void* data, int length, int location, bool hold_data);
      
      int            SetupPtr(const VectorClass<T> &vec, int length, int shift);
      
      int            SetupPtr(const VectorClass<T> &vec, int length, int shift, bool hold_data);
      
      int            Copy(const T *data, int length, int loc_from, int loc_to);
      
      int            PushBack(T v);
      
      int            Resize(int length, bool keepdata, bool setzero);
      
      int            Resize(int length, int reserve, bool keepdata, bool setzero);
      
      virtual T&     operator[] (int i);
      
      virtual int    Clear();
      
      virtual T*     GetData() const;
 
#ifdef PARGEMSLR_CUDA 
#if (PARGEMSLR_CUDA_VERSION == 11)
 
      virtual cusparseDnVecDescr_t  GetCusparseVec() const;
      
      int     SetCusparseVec(cusparseDnVecDescr_t cusparse_vec);
#endif
#endif
 
      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);
      
      virtual int    Fill(const T &v);
      
      virtual int    Rand();
      
      T              Max() const;
      
      int            MaxIndex() const;
      
      T              Min() const;
      
      int            MinIndex() const;
      
      int            BinarySearch(const T &val, int &idx, bool ascending);
      
      int            Sort(bool ascending);
      
      int            Sort(IntVectorClass<int> &order, bool ascending, bool stable);
      
      int            Perm(IntVectorClass<int> &perm);
      
      int            Plot( int conditiona, int conditionb, int width);
      
      int            PlotAbsGnuPlot( const char *datafilename, int conditiona, int conditionb, bool logx, bool logy, int pttype = 0);
      
      int            WriteToDisk( const char *datafilename);
      
      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> &z);
      
      virtual int    Axpy( const T &alpha, const VectorClass<T> &x, const T &beta, VectorClass<T> &z);
      
      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 int MoveData( const int &location);
      
      int            ReadFromMMFile(const char *vecfile, int idxin);
      
   };
   
   typedef SequentialVectorClass<float>     vector_seq_float;
   typedef SequentialVectorClass<double>    vector_seq_double;
   typedef SequentialVectorClass<complexs>  vector_seq_complexs;
   typedef SequentialVectorClass<complexd>  vector_seq_complexd;
   template<> struct PargemslrIsComplex<SequentialVectorClass<complexs> > : public std::true_type {};
   template<> struct PargemslrIsComplex<SequentialVectorClass<complexd> > : public std::true_type {};
   
}
 
#endif