Morpheus_MatrixBase.hpp

 
#ifndef MORPHEUS_MATRIXBASE_HPP
#define MORPHEUS_MATRIXBASE_HPP
 
#include <Morpheus_MatrixOptions.hpp>
#include <Morpheus_ContainerTraits.hpp>
 
namespace Morpheus {
 
template <template <class, class...> class Container, class ValueType,
          class... Properties>
class MatrixBase : public ContainerTraits<Container, ValueType, Properties...> {
 public:
  using type = MatrixBase<Container, ValueType, Properties...>;
  using traits = ContainerTraits<Container, ValueType, Properties...>;
  using size_type = typename traits::size_type;
  MatrixBase()
      : _m(0), _n(0), _nnz(0), _structure(MATSTR_NONE), _options(MATOPT_NONE) {}
 
  MatrixBase(size_type rows, size_type cols, size_type entries = 0)
      : _m(rows),
        _n(cols),
        _nnz(entries),
        _structure(MATSTR_NONE),
        _options(MATOPT_NONE) {}
 
  void resize(size_type rows, size_type cols, size_type entries) {
    _m   = rows;
    _n   = cols;
    _nnz = entries;
  }
 
  inline size_type nrows() const { return _m; }
 
  inline size_type ncols() const { return _n; }
 
  inline size_type nnnz() const { return _nnz; }
 
  inline void set_nrows(const size_type rows) { _m = rows; }
 
  inline void set_ncols(const size_type cols) { _n = cols; }
 
  inline void set_nnnz(const size_type nnz) { _nnz = nnz; }
 
  inline MatrixStructure structure() const { return _structure; }
  inline MatrixOptions options() const { return _options; }
 
  inline void set_structure(MatrixStructure op) { _structure = op; }
 
  inline void set_options(MatrixOptions op) { _options = op; }
 
 private:
  size_type _m, _n, _nnz;
  MatrixStructure _structure;
  MatrixOptions _options;
};
}  // namespace Morpheus
 
#endif  // MORPHEUS_MATRIXBASE_HPP