Morpheus_DenseVector.hpp

 
#ifndef MORPHEUS_DENSEVECTOR_HPP
#define MORPHEUS_DENSEVECTOR_HPP
 
#include <Morpheus_FormatTraits.hpp>
#include <Morpheus_FormatTags.hpp>
#include <Morpheus_ContainerTraits.hpp>
 
#include <impl/Morpheus_Functors.hpp>
 
#include <Kokkos_Core.hpp>
#include <Kokkos_Random.hpp>
 
namespace Morpheus {
 
template <class ValueType, class... Properties>
class DenseVector
    : public ContainerTraits<DenseVector, ValueType, Properties...> {
 public:
  using traits = ContainerTraits<DenseVector, ValueType, Properties...>;
  using type = typename traits::type;
  using tag = typename VectorFormatTag<Morpheus::DenseVectorFormatTag>::tag;
 
  using value_type = typename traits::value_type;
  using non_const_value_type = typename traits::non_const_value_type;
  using size_type            = typename traits::size_type;
  using index_type = typename traits::index_type;
  using non_const_index_type = typename traits::non_const_index_type;
 
  using array_layout    = typename traits::array_layout;
  using backend         = typename traits::backend;
  using memory_space    = typename traits::memory_space;
  using execution_space = typename traits::execution_space;
  using device_type     = typename traits::device_type;
  using memory_traits   = typename traits::memory_traits;
  using HostMirror      = typename traits::HostMirror;
 
  using pointer         = typename traits::pointer;
  using const_pointer   = typename traits::const_pointer;
  using reference       = typename traits::reference;
  using const_reference = typename traits::const_reference;
 
  using value_array_type =
      Kokkos::View<value_type*, array_layout, execution_space, memory_traits>;
  using value_array_pointer   = typename value_array_type::pointer_type;
  using value_array_reference = typename value_array_type::reference_type;
 
  ~DenseVector() = default;
  DenseVector(const DenseVector&) = default;
  DenseVector(DenseVector&&) = default;
  DenseVector& operator=(const DenseVector&) = default;
  DenseVector& operator=(DenseVector&&) = default;
 
  inline DenseVector() : _size(0), _values() {}
 
  inline DenseVector(const size_type n, value_type val = 0)
      : _size(n), _values("vector", n) {
    assign(n, val);
  }
 
  template <typename ValuePtr>
  DenseVector(const size_type n, ValuePtr ptr,
              typename std::enable_if<std::is_pointer<ValuePtr>::value>::type* =
                  nullptr)
      : _size(n), _values(ptr, n) {
    static_assert(std::is_same<value_array_pointer, ValuePtr>::value,
                  "Constructing DenseVector to wrap user memory must supply "
                  "matching pointer type");
  }
 
  template <typename Generator>
  inline DenseVector(const size_type n, Generator rand_pool,
                     const value_type range_low, const value_type range_high)
      : _size(n), _values("vector", n) {
    Kokkos::fill_random(_values, rand_pool, range_low, range_high);
  }
 
  template <class VR, class... PR>
  inline DenseVector(
      const DenseVector<VR, PR...>& src,
      typename std::enable_if_t<
          is_compatible<DenseVector, DenseVector<VR, PR...>>::value>* = nullptr)
      : _size(src.size()), _values(src.const_view()) {}
 
  template <class VR, class... PR>
  typename std::enable_if_t<
      is_compatible<DenseVector, DenseVector<VR, PR...>>::value, DenseVector&>
  operator=(const DenseVector<VR, PR...>& src) {
    _size   = src.size();
    _values = src.const_view();
    return *this;
  }
 
  template <class VR, class... PR>
  inline DenseVector& allocate(const DenseVector<VR, PR...>& src) {
    _size = src.size();
    this->resize(src.size());
    return *this;
  }
 
  inline void assign(const size_type n, const value_type val) {
    using range_policy = Kokkos::RangePolicy<size_type, execution_space>;
 
    range_policy policy(0, n);
    Impl::set_functor<value_array_type, value_type> f(_values, val);
    Kokkos::parallel_for("Morpheus::DenseVector::assign", policy, f);
  }
 
  template <typename Generator>
  inline void assign(const size_type n, Generator rand_pool,
                     const value_type range_low, const value_type range_high) {
    auto vals = Kokkos::subview(_values, std::make_pair(size_type(0), n));
    Kokkos::fill_random(vals, rand_pool, range_low, range_high);
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION value_array_reference
  operator()(const size_type i) const {
    return _values(i);
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION value_array_reference
  operator[](const size_type i) const {
    return _values(i);
  }
 
  inline size_type size() const { return _size; }
 
  inline value_array_pointer data() const { return _values.data(); }
 
  inline value_array_type& view() { return _values; }
 
  inline const value_array_type& const_view() const { return _values; }
 
  inline void resize(const size_type n) {
    Kokkos::resize(_values, n);
    _size = n;
  }
 
  inline void resize(const size_type n, const value_type val) {
    resize(n);
    assign(n, val);
  }
 
  template <class VR, class... PR>
  inline void resize(const DenseVector<VR, PR...>& src) {
    resize(src.size());
  }
 
 private:
  size_type _size;
  value_array_type _values;
};
 
}  // namespace Morpheus
 
#endif  // MORPHEUS_DENSEVECTOR_HPP