Morpheus_DynamicMatrix.hpp

 
#ifndef MORPHEUS_DYNAMICMATRIX_HPP
#define MORPHEUS_DYNAMICMATRIX_HPP
 
#include <Morpheus_FormatTags.hpp>
#include <Morpheus_MatrixBase.hpp>
 
#include <impl/Morpheus_Variant.hpp>
#include <impl/Dynamic/Morpheus_DynamicMatrix_Impl.hpp>
 
#include <iostream>
#include <string>
#include <functional>
 
namespace Morpheus {
 
template <class ValueType, class... Properties>
class DynamicMatrix
    : public MatrixBase<DynamicMatrix, ValueType, Properties...> {
 public:
  using traits = ContainerTraits<DynamicMatrix, ValueType, Properties...>;
  using type = typename traits::type;
  using base = MatrixBase<DynamicMatrix, ValueType, Properties...>;
  using tag = typename MatrixFormatTag<Morpheus::DynamicMatrixFormatTag>::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 variant_type =
      typename MatrixFormats<ValueType, Properties...>::variant;
 
  ~DynamicMatrix() = default;
  DynamicMatrix(const DynamicMatrix &) = default;
  DynamicMatrix(DynamicMatrix &&) = default;
  DynamicMatrix &operator=(const DynamicMatrix &) = default;
  DynamicMatrix &operator=(DynamicMatrix &&) = default;
 
  inline DynamicMatrix() : _formats() {}
 
  template <typename Matrix>
  inline DynamicMatrix(
      const Matrix &src,
      typename std::enable_if<is_variant_member_v<Matrix, variant_type>>::type
          * = nullptr) {
    this->activate(src.format_enum());
    base::resize(src.nrows(), src.ncols(), src.nnnz());
 
    auto f = std::bind(Impl::any_type_assign(), std::cref(src),
                       std::placeholders::_1);
    Morpheus::Impl::Variant::visit(f, _formats);
  }
 
  template <typename Matrix>
  typename std::enable_if<is_variant_member_v<Matrix, variant_type>,
                          DynamicMatrix &>::type
  operator=(const Matrix &matrix) {
    this->activate(matrix.format_enum());
    base::resize(matrix.nrows(), matrix.ncols(), matrix.nnnz());
 
    auto f = std::bind(Impl::any_type_assign(), std::cref(matrix),
                       std::placeholders::_1);
    Morpheus::Impl::Variant::visit(f, _formats);
    return *this;
  }
 
  template <class VR, class... PR>
  DynamicMatrix(
      const DynamicMatrix<VR, PR...> &src,
      typename std::enable_if<is_format_compatible<
          DynamicMatrix, DynamicMatrix<VR, PR...>>::value>::type * = nullptr) {
    this->activate(src.active_index());  // switch to src format
    base::resize(src.nrows(), src.ncols(), src.nnnz());
 
    Morpheus::Impl::Variant::visit(Impl::any_type_assign(), src.const_formats(),
                                   _formats);
  }
 
  template <class VR, class... PR>
  typename std::enable_if<
      is_format_compatible<DynamicMatrix, DynamicMatrix<VR, PR...>>::value,
      DynamicMatrix &>::type
  operator=(const DynamicMatrix<VR, PR...> &src) {
    this->activate(src.active_index());  // switch to src format
    base::resize(src.nrows(), src.ncols(), src.nnnz());
 
    Morpheus::Impl::Variant::visit(Impl::any_type_assign(), src.const_formats(),
                                   _formats);
 
    return *this;
  }
 
  // template <typename... Args>
  // inline void resize(const size_type m, const size_type n,
  //                    const size_type nnz, Args &&... args) {
  //   base::resize(m, n, nnz);
  //   auto f = std::bind(Impl::any_type_resize<ValueType, Properties...>(),
  //                      std::placeholders::_1, m, n, nnz,
  //                      std::forward<Args>(args)...);
  //   return Morpheus::Impl::Variant::visit(f, _formats);
  // }
 
  template <class VR, class... PR>
  inline void resize(const DynamicMatrix<VR, PR...> &src) {
    this->activate(src.format_enum());
    base::resize(src.nrows(), src.ncols(), src.nnnz());
 
    Morpheus::Impl::Variant::visit(Impl::any_type_resize_from_mat(),
                                   src.const_formats(), _formats);
  }
 
  template <typename Matrix>
  inline void resize(
      const Matrix &src,
      typename std::enable_if<is_variant_member_v<Matrix, variant_type>>::type
          * = nullptr) {
    this->activate(src.format_enum());
    base::resize(src.nrows(), src.ncols(), src.nnnz());
 
    auto f = std::bind(Impl::any_type_resize_from_mat(), std::cref(src),
                       std::placeholders::_1);
    Morpheus::Impl::Variant::visit(f, _formats);
  }
 
  template <class VR, class... PR>
  inline DynamicMatrix &allocate(const DynamicMatrix<VR, PR...> &src) {
    this->activate(src.active_index());  // switch to src format
    base::resize(src.nrows(), src.ncols(), src.nnnz());
 
    Morpheus::Impl::Variant::visit(Impl::any_type_allocate(),
                                   src.const_formats(), _formats);
    return *this;
  }
 
  inline int active_index() const { return _formats.index(); }
 
  int format_index() const { return this->active_index(); }
 
  inline formats_e active_enum() const {
    return static_cast<formats_e>(_formats.index());
  }
 
  inline formats_e format_enum() const { return this->active_enum(); }
 
  inline void activate(const formats_e index) {
    constexpr int size = Morpheus::Impl::Variant::variant_size_v<
        typename MatrixFormats<ValueType, Properties...>::variant>;
    const int idx = static_cast<int>(index);
 
    if (idx == active_index()) {
      return;
    } else if (idx > size) {
      std::cout << "Warning: There are " << size
                << " available formats to switch to. "
                << "Selecting to switch to format with index " << idx
                << " will default to no change." << std::endl;
 
      return;
    }
 
    // Set metadata to 0
    base::resize(0, 0, 0);
    Impl::activate_impl<size, ValueType, Properties...>::activate(_formats,
                                                                  idx);
  }
 
  inline void activate(const int index) {
    activate(static_cast<formats_e>(index));
  }
 
  inline const variant_type &const_formats() const { return _formats; }
 
  inline variant_type &formats() { return _formats; }
 
 private:
  variant_type _formats;
};
}  // namespace Morpheus
 
#endif  // MORPHEUS_DYNAMICMATRIX_HPP