int_vector.hpp

Go to the documentation of this file.

#ifndef PARGEMSLR_INT_VECTOR_H
#define PARGEMSLR_INT_VECTOR_H
 
#include "../utils/utils.hpp"
#include "vector.hpp"
#include <algorithm>
#include <iostream>
 
#ifdef PARGEMSLR_CUDA
#include "cusparse.h"
#endif
 
namespace pargemslr
{
   
   template <typename T>
   class IntVectorClass: public VectorVirtualClass<T>
   {
   private:
      
      T*             _data;
      
      int            _length;
      
      int            _maxlength;
      
      bool           _hold_data;
      
      int            _location;
      
      
   public:
      
      IntVectorClass();
      
      IntVectorClass(const IntVectorClass<T> &vec);
      
      IntVectorClass(IntVectorClass<T> &&vec);
      
      IntVectorClass<T>& operator= (const IntVectorClass<T> &vec);
      
      IntVectorClass<T>& operator= (IntVectorClass<T> &&vec);
      
      virtual ~IntVectorClass();
      
      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            SetupPtr( T* data, int length, int location);
      
      int            SetupPtr( T* data, int length, int location, bool hold_data);
      
      int            SetupPtr(const IntVectorClass<T> &vec, int length, int shift);
      
      int            SetupPtr(const IntVectorClass<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);
      
      T&             Back();
      
      virtual int    Clear();
      
      virtual T*     GetData() const;
 
      virtual int    GetDataLocation() const;
      
      virtual int    GetLengthLocal() const;
      
      virtual int    Fill(const T &v);
      
      int              UnitPerm();
      
      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);
      
      template <typename T1>
      int ScatterRperm(const VectorVirtualClass<T1> &v_in, VectorVirtualClass<T1> &v_out);
      
      template <typename T1>
      int GatherPerm(const VectorVirtualClass<T1> &v_in, VectorVirtualClass<T1> &v_out);
      
      virtual int MoveData( const int &location);
      
   };
   
   typedef IntVectorClass<int>         vector_int;
   typedef IntVectorClass<long int>    vector_long;
   template<> struct PargemslrIsComplex<IntVectorClass<complexs> > : public std::true_type {};
   template<> struct PargemslrIsComplex<IntVectorClass<complexd> > : public std::true_type {};
   
}
 
#endif