Morpheus_CooMatrix.hpp

 
#ifndef MORPHEUS_COOMATRIX_HPP
#define MORPHEUS_COOMATRIX_HPP
 
#include <Morpheus_Exceptions.hpp>
#include <Morpheus_FormatTags.hpp>
#include <Morpheus_DenseVector.hpp>
#include <Morpheus_DynamicMatrix.hpp>
#include <Morpheus_Sort.hpp>
#include <Morpheus_MatrixBase.hpp>
 
namespace Morpheus {
 
template <class ValueType, class... Properties>
class CooMatrix : public MatrixBase<CooMatrix, ValueType, Properties...> {
 public:
  using traits = ContainerTraits<CooMatrix, ValueType, Properties...>;
  using type = typename traits::type;
  using base = MatrixBase<CooMatrix, ValueType, Properties...>;
  using tag = typename MatrixFormatTag<Morpheus::CooFormatTag>::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 index_array_type =
      Morpheus::DenseVector<index_type, size_type, array_layout, backend,
                            memory_traits>;
  using index_array_pointer = typename index_array_type::value_array_pointer;
  using index_array_reference =
      typename index_array_type::value_array_reference;
 
  using value_array_type =
      Morpheus::DenseVector<value_type, size_type, array_layout, backend,
                            memory_traits>;
  using value_array_pointer = typename value_array_type::value_array_pointer;
  using value_array_reference =
      typename value_array_type::value_array_reference;
 
  ~CooMatrix() = default;
  CooMatrix(const CooMatrix &) = default;
  CooMatrix(CooMatrix &&) = default;
  CooMatrix &operator=(const CooMatrix &) = default;
  CooMatrix &operator=(CooMatrix &&) = default;
 
  inline CooMatrix() : base(), _row_indices(), _column_indices(), _values() {}
 
  inline CooMatrix(const size_type num_rows, const size_type num_cols,
                   const size_type num_entries)
      : base(num_rows, num_cols, num_entries),
        _row_indices(num_entries),
        _column_indices(num_entries),
        _values(num_entries) {}
 
  // Construct from raw pointers
  template <typename ValuePtr, typename IndexPtr>
  explicit inline CooMatrix(
      const size_type num_rows, const size_type num_cols,
      const size_type num_entries, IndexPtr rind_ptr, IndexPtr cind_ptr,
      ValuePtr vals_ptr,
      typename std::enable_if<
          (std::is_pointer<ValuePtr>::value &&
           is_same_value_type<value_type, ValuePtr>::value &&
           memory_traits::is_unmanaged) &&
          (std::is_pointer<IndexPtr>::value &&
           is_same_index_type<index_type, IndexPtr>::value &&
           memory_traits::is_unmanaged)>::type * = nullptr)
      : base(num_rows, num_cols, num_entries),
        _row_indices(size_t(num_entries), rind_ptr),
        _column_indices(size_t(num_entries), cind_ptr),
        _values(size_t(num_entries), vals_ptr) {}
 
  template <typename ValueArray, typename IndexArray>
  explicit inline CooMatrix(
      const size_type num_rows, const size_type num_cols,
      const size_type num_entries, IndexArray rind, IndexArray cind,
      ValueArray vals,
      typename std::enable_if<
          is_dense_vector_format_container<ValueArray>::value &&
          is_dense_vector_format_container<IndexArray>::value &&
          is_compatible<typename CooMatrix::value_array_type,
                        ValueArray>::value &&
          is_compatible<typename CooMatrix::index_array_type,
                        IndexArray>::value &&
          !ValueArray::memory_traits::is_unmanaged &&
          !IndexArray::memory_traits::is_unmanaged>::type * = nullptr)
      : base(num_rows, num_cols, num_entries),
        _row_indices(rind),
        _column_indices(cind),
        _values(vals) {}
 
  template <class VR, class... PR>
  CooMatrix(const CooMatrix<VR, PR...> &src,
            typename std::enable_if<is_format_compatible<
                CooMatrix, CooMatrix<VR, PR...>>::value>::type * = nullptr)
      : base(src.nrows(), src.ncols(), src.nnnz()),
        _row_indices(src.crow_indices()),
        _column_indices(src.ccolumn_indices()),
        _values(src.cvalues()) {}
 
  template <class VR, class... PR>
  typename std::enable_if<
      is_format_compatible<CooMatrix, CooMatrix<VR, PR...>>::value,
      CooMatrix &>::type
  operator=(const CooMatrix<VR, PR...> &src) {
    this->set_nrows(src.nrows());
    this->set_ncols(src.ncols());
    this->set_nnnz(src.nnnz());
 
    _row_indices    = src.crow_indices();
    _column_indices = src.ccolumn_indices();
    _values         = src.cvalues();
 
    return *this;
  }
 
  template <class VR, class... PR>
  CooMatrix(const DynamicMatrix<VR, PR...> &src,
            typename std::enable_if<is_dynamically_compatible<
                CooMatrix, DynamicMatrix<VR, PR...>>::value>::type * = nullptr)
      : base(src.nrows(), src.ncols(), src.nnnz()) {
    auto f = std::bind(Impl::any_type_assign(), std::placeholders::_1,
                       std::ref(*this));
 
    std::visit(f, src.const_formats());
  }
 
  template <class VR, class... PR>
  typename std::enable_if<
      is_dynamically_compatible<CooMatrix, DynamicMatrix<VR, PR...>>::value,
      CooMatrix &>::type
  operator=(const DynamicMatrix<VR, PR...> &src) {
    auto f = std::bind(Impl::any_type_assign(), std::placeholders::_1,
                       std::ref(*this));
 
    std::visit(f, src.const_formats());
 
    return *this;
  }
 
  template <typename MatrixType>
  CooMatrix(const MatrixType &src) = delete;
 
  template <typename MatrixType>
  reference operator=(const MatrixType &src) = delete;
 
  inline void resize(const size_type num_rows, const size_type num_cols,
                     const size_type num_entries) {
    base::resize(num_rows, num_cols, num_entries);
    _row_indices.resize(num_entries);
    _column_indices.resize(num_entries);
    _values.resize(num_entries);
  }
 
  template <class VR, class... PR>
  inline void resize(const CooMatrix<VR, PR...> &src) {
    resize(src.nrows(), src.ncols(), src.nnnz());
  }
 
  template <class VR, class... PR>
  inline CooMatrix &allocate(const CooMatrix<VR, PR...> &src) {
    resize(src.nrows(), src.ncols(), src.nnnz());
    return *this;
  }
 
  void sort_by_row(void) {
    throw Morpheus::NotImplementedException("CooMatrix.sort_by_row()");
  }
 
  void sort(void) { Morpheus::sort_by_row_and_column<backend>(*this); }
 
  bool is_sorted_by_row(void) {
    throw Morpheus::NotImplementedException("CooMatrix.is_sorted_by_row()");
    return true;
  }
 
  bool is_sorted(void) { return Morpheus::is_sorted<backend>(*this); }
 
  formats_e format_enum() const { return _id; }
 
  int format_index() const { return static_cast<int>(_id); }
 
  MORPHEUS_FORCEINLINE_FUNCTION index_array_reference row_indices(size_type n) {
    return _row_indices(n);
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION index_array_reference
  column_indices(size_type n) {
    return _column_indices(n);
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION value_array_reference values(size_type n) {
    return _values(n);
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION const index_array_reference
  crow_indices(size_type n) const {
    return _row_indices(n);
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION const index_array_reference
  ccolumn_indices(size_type n) const {
    return _column_indices(n);
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION const value_array_reference
  cvalues(size_type n) const {
    return _values(n);
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION index_array_type &row_indices() {
    return _row_indices;
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION index_array_type &column_indices() {
    return _column_indices;
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION value_array_type &values() { return _values; }
 
  MORPHEUS_FORCEINLINE_FUNCTION const index_array_type &crow_indices() const {
    return _row_indices;
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION const index_array_type &ccolumn_indices()
      const {
    return _column_indices;
  }
 
  MORPHEUS_FORCEINLINE_FUNCTION const value_array_type &cvalues() const {
    return _values;
  }
 
 private:
  index_array_type _row_indices, _column_indices;
  value_array_type _values;
  static constexpr formats_e _id = Morpheus::COO_FORMAT;
};
}  // namespace Morpheus
 
#endif  // MORPHEUS_COOMATRIX_HPP