local_vector.hpp

Go to the documentation of this file.

#ifndef PARALUTION_LOCAL_VECTOR_HPP_
#define PARALUTION_LOCAL_VECTOR_HPP_

#include "vector.hpp"
#include "base_vector.hpp"
#include "host/host_vector.hpp"

namespace paralution {

template <typename ValueType>
class LocalMatrix;

template <typename ValueType>
class LocalStencil;

// Local vector
template <typename ValueType>
class LocalVector : public Vector<ValueType> {

public:

  LocalVector();
  virtual ~LocalVector();

  virtual void MoveToAccelerator(void);
  virtual void MoveToAcceleratorAsync(void);
  virtual void MoveToHost(void);
  virtual void MoveToHostAsync(void);
  virtual void Sync(void);

  virtual void info(void) const;
  virtual int get_size(void) const;

  virtual bool Check(void) const;

  virtual void Allocate(std::string name, const int size);

  void SetDataPtr(ValueType **ptr, std::string name, const int size);
  void LeaveDataPtr(ValueType **ptr);

  void Assemble(const int *i, const ValueType *v,
                int size, std::string name, const int n=0);

  virtual void Clear();
  virtual void Zeros();
  virtual void Ones();
  virtual void SetValues(const ValueType val);
  virtual void SetRandom(const ValueType a = -1.0, const ValueType b = 1.0, const int seed = 0);

  ValueType& operator[](const int i);
  const ValueType& operator[](const int i) const;

  virtual void ReadFileASCII(const std::string filename);
  virtual void WriteFileASCII(const std::string filename) const;
  virtual void ReadFileBinary(const std::string filename);
  virtual void WriteFileBinary(const std::string filename) const;

  virtual void CopyFrom(const LocalVector<ValueType> &src);
  virtual void CopyFromAsync(const LocalVector<ValueType> &src);
  virtual void CopyFromFloat(const LocalVector<float> &src);
  virtual void CopyFromDouble(const LocalVector<double> &src);

  void CopyFrom(const LocalVector<ValueType> &src,
                const int src_offset,
                const int dst_offset,
                const int size);

  void CopyFromPermute(const LocalVector<ValueType> &src,
                       const LocalVector<int> &permutation);

  void CopyFromPermuteBackward(const LocalVector<ValueType> &src,
                               const LocalVector<int> &permutation);

  void CloneFrom(const LocalVector<ValueType> &src);

  void CopyFromData(const ValueType *data);

  void CopyToData(ValueType *data) const;

  void Permute(const LocalVector<int> &permutation);

  void PermuteBackward(const LocalVector<int> &permutation);

  void Restriction(const LocalVector<ValueType> &vec_fine, const LocalVector<int> &map);

  void Prolongation(const LocalVector<ValueType> &vec_coarse, const LocalVector<int> &map);

  virtual void AddScale(const LocalVector<ValueType> &x, const ValueType alpha);
  virtual void ScaleAdd(const ValueType alpha, const LocalVector<ValueType> &x);
  virtual void ScaleAddScale(const ValueType alpha, const LocalVector<ValueType> &x, const ValueType beta);
  void ScaleAddScale(const ValueType alpha, const LocalVector<ValueType> &x, const ValueType beta,
                     const int src_offset,
                     const int dst_offset,
                     const int size);

  virtual void ScaleAdd2(const ValueType alpha, const LocalVector<ValueType> &x, const ValueType beta, const LocalVector<ValueType> &y, const ValueType gamma);
  virtual void Scale(const ValueType alpha);
  virtual void PartialSum(const LocalVector<ValueType> &x);
  virtual ValueType Dot(const LocalVector<ValueType> &x) const;
  virtual ValueType DotNonConj(const LocalVector<ValueType> &x) const;
  virtual ValueType Norm(void) const;
  virtual ValueType Reduce(void) const;
  virtual ValueType Asum(void) const;
  virtual int Amax(ValueType &value) const;
  virtual void PointWiseMult(const LocalVector<ValueType> &x);
  virtual void PointWiseMult(const LocalVector<ValueType> &x, const LocalVector<ValueType> &y);
  virtual void Power(const double power);

protected:

  virtual bool is_host(void) const;
  virtual bool is_accel(void) const;

private:

  BaseVector<ValueType> *vector_;

  HostVector<ValueType> *vector_host_;

  AcceleratorVector<ValueType> *vector_accel_;

  friend class LocalVector<double>;
  friend class LocalVector<float>;
  friend class LocalVector<std::complex<double> >;
  friend class LocalVector<std::complex<float> >;
  friend class LocalVector<int>;

  friend class LocalMatrix<double>;
  friend class LocalMatrix<float>;
  friend class LocalMatrix<std::complex<double> >;
  friend class LocalMatrix<std::complex<float> >;

  friend class LocalStencil<double>;
  friend class LocalStencil<float>;
  friend class LocalStencil<std::complex<double> >;
  friend class LocalStencil<std::complex<float> >;

  friend class LocalMatrix<ValueType>;

};


}

#endif // PARALUTION_LOCAL_VECTOR_HPP_