Morpheus_DenseMatrix.hpp

 
#ifndef MORPHEUS_DENSEMATRIX_HPP
#define MORPHEUS_DENSEMATRIX_HPP
 
#include <Morpheus_Exceptions.hpp>
#include <Morpheus_FormatTags.hpp>
#include <Morpheus_MatrixBase.hpp>
 
#include <impl/Morpheus_Functors.hpp>
 
#include <Kokkos_Core.hpp>
 
namespace Morpheus {
 
template <class ValueType, class... Properties>
class DenseMatrix : public MatrixBase<DenseMatrix, ValueType, Properties...> {
 public:
  using traits = ContainerTraits<DenseMatrix, ValueType, Properties...>;
  using type = typename traits::type;
  using base = MatrixBase<DenseMatrix, ValueType, Properties...>;
  using tag = typename MatrixFormatTag<Morpheus::DenseMatrixFormatTag>::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;
 
  ~DenseMatrix() = default;
  DenseMatrix(const DenseMatrix &) = default;
  DenseMatrix(DenseMatrix &&) = default;
  DenseMatrix &operator=(const DenseMatrix &) = default;
  DenseMatrix &operator=(DenseMatrix &&) = default;
 
  inline DenseMatrix() : base(), _values() {}
 
  inline DenseMatrix(const size_type num_rows, const size_type num_cols,
                     const value_type val = 0)
      : base(num_rows, num_cols, num_rows * num_cols),
        _values("matrix", size_t(num_rows), size_t(num_cols)) {
    assign(num_rows, num_cols, val);
  }
 
  template <typename ValuePtr>
  explicit DenseMatrix(
      const size_type num_rows, const size_type num_cols, ValuePtr ptr,
      typename std::enable_if<std::is_pointer<ValuePtr>::value &&
                              is_same_value_type<value_type, ValuePtr>::value &&
                              memory_traits::is_unmanaged>::type * = nullptr)
      : base(num_rows, num_cols, num_rows * num_cols),
        _values(ptr, size_t(num_rows), size_t(num_cols)) {
    static_assert(std::is_same<value_array_pointer, ValuePtr>::value,
                  "Constructing DenseMatrix to wrap user memory must supply "
                  "matching pointer type");
  }
 
  template <class VR, class... PR>
  inline DenseMatrix(
      const DenseMatrix<VR, PR...> &src,
      typename std::enable_if<is_format_compatible<
          DenseMatrix, DenseMatrix<VR, PR...>>::value>::type * = nullptr)
      : base(src.nrows(), src.ncols(), src.nrows() * src.ncols()),
        _values(src.const_view()) {}
 
  template <class VR, class... PR>
  typename std::enable_if<
      is_format_compatible<DenseMatrix, DenseMatrix<VR, PR...>>::value,
      DenseMatrix &>::type
  operator=(const DenseMatrix<VR, PR...> &src) {
    this->set_nrows(src.nrows());
    this->set_ncols(src.ncols());
    this->set_nnnz(src.nnnz());
    _values = src.const_view();
    return *this;
  }
 
  template <class MatrixType>
  DenseMatrix(const MatrixType &src) = delete;
 
  template <class MatrixType>
  reference operator=(const MatrixType &src) = delete;
 
  inline void assign(size_type num_rows, size_type num_cols,
                     const value_type val) {
    using range_policy = Kokkos::RangePolicy<size_type, execution_space>;
 
    range_policy policy(0, num_rows);
    Impl::set_functor<value_array_type, value_type, size_type> f(_values, val,
                                                                 num_cols);
    Kokkos::parallel_for("Morpheus::DenseMatrix::assign", policy, f);
  }
 
  inline void resize(size_type num_rows, size_type num_cols) {
    base::resize(num_rows, num_cols, num_rows * num_cols);
    Kokkos::resize(_values, size_t(num_rows), size_t(num_cols));
  }
 
  template <class VR, class... PR>
  inline void resize(const DenseMatrix<VR, PR...> &src) {
    resize(src.nrows(), src.ncols());
  }
 
  template <class VR, class... PR>
  inline DenseMatrix &allocate(const DenseMatrix<VR, PR...> &src) {
    resize(src.nrows(), src.ncols());
    return *this;
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION value_array_reference
  operator()(size_type i, size_type j) const {
    return _values(i, j);
  }
 
  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; }
 
 private:
  value_array_type _values;
};
 
}  // namespace Morpheus
 
#endif  // MORPHEUS_DENSEMATRIX_HPP