local_vector.hpp

// **************************************************************************
//
//    PARALUTION   www.paralution.com
//
//    Copyright (C) 2015  PARALUTION Labs UG (haftungsbeschränkt) & Co. KG
//                        Am Hasensprung 6, 76571 Gaggenau
//                        Handelsregister: Amtsgericht Mannheim, HRA 706051
//                        Vertreten durch:
//                        PARALUTION Labs Verwaltungs UG (haftungsbeschränkt)
//                        Am Hasensprung 6, 76571 Gaggenau
//                        Handelsregister: Amtsgericht Mannheim, HRB 721277
//                        Geschäftsführer: Dimitar Lukarski, Nico Trost
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// **************************************************************************



// PARALUTION version 1.1.0 


#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;

  /// Allocate a local vector with name and size
  virtual void Allocate(std::string name, const int size);

  /// Initialize a vector with externally allocated data
  void SetDataPtr(ValueType **ptr, std::string name, const int size);
  /// Get a pointer from the vector data and free the vector object
  void LeaveDataPtr(ValueType **ptr);

  /// Assembling
  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);

  /// Access operator (only for host data!)
  ValueType& operator[](const int i);
  /// Access operator (only for host data!)
  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);

  /// Copy data (not entire vector) from another local vector with specified src/dst offsets and size
  void CopyFrom(const LocalVector<ValueType> &src,
                const int src_offset,
                const int dst_offset,
                const int size);

  /// Copy a local vector under specified permutation (forward permutation)
  void CopyFromPermute(const LocalVector<ValueType> &src,
                       const LocalVector<int> &permutation);

  /// Copy a local vector under specified permutation (backward permutation)
  void CopyFromPermuteBackward(const LocalVector<ValueType> &src,
                               const LocalVector<int> &permutation);

  /// Clone the entire vector (values,backend descr) from another LocalVector
  void CloneFrom(const LocalVector<ValueType> &src);

  /// Copy (import) vector described in one array (values)
  /// The object data has to be allocated (call Allocate first)
  void CopyFromData(const ValueType *data);

  /// Copy (export) vector described in one array (values)
  /// The output array has to be allocated
  void CopyToData(ValueType *data) const;

  /// Perform inplace permutation (forward) of the vector
  void Permute(const LocalVector<int> &permutation);

  /// Perform inplace permutation (backward) of the vector
  void PermuteBackward(const LocalVector<int> &permutation);

  /// Restriction operator based on restriction mapping vector
  void Restriction(const LocalVector<ValueType> &vec_fine, const LocalVector<int> &map);

  /// Prolongation operator based on restriction(!) mapping vector
  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);
  /// Perform vector update of type this = alpha*this + x*beta with offsets for a specified part of a vector
  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 ExclusiveScan(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:

  /// Pointer from the base vector class to the current allocated vector (host_ or accel_)
  BaseVector<ValueType> *vector_;

  /// Host Vector
  HostVector<ValueType> *vector_host_;

  /// Accelerator Vector
  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_