parameterize matrix on how it is sliced

Author: alyst

inst/include/cpp11/matrix.hpp

@@ -10,25 +10,94 @@
 #include "cpp11/sexp.hpp"      // for sexp
 
 namespace cpp11 {
-template <typename V, typename T>
-class matrix {
+
+// matrix dimensions
+struct matrix_dims {
+protected:
+  const int nrow_;
+  const int ncol_;
+
+public:
+  matrix_dims(SEXP data) : nrow_(Rf_nrows(data)), ncol_(Rf_ncols(data)) {}
+  matrix_dims(int nrow, int ncol) : nrow_(nrow), ncol_(ncol) {}
+
+  int nrow() const { return nrow_; }
+  int ncol() const { return ncol_; }
+};
+
+// base type for dimension-wise matrix access specialization
+struct matrix_slice {};
+
+struct by_row: public matrix_slice {};
+struct by_column: public matrix_slice {};
+
+// basic properties of matrix slices
+template<typename S>
+struct matrix_slices: public matrix_dims {
+public:
+  using matrix_dims::matrix_dims;
+  using matrix_dims::nrow;
+  using matrix_dims::ncol;
+
+  int nslices() const;
+  int slice_size() const;
+  int slice_stride() const;
+  int slice_offset(int pos) const;
+};
+
+// basic properties of matrix row slices
+template<>
+struct matrix_slices<by_row>: public matrix_dims {
+public:
+  using matrix_dims::matrix_dims;
+  using matrix_dims::nrow;
+  using matrix_dims::ncol;
+
+  int nslices() const { return nrow(); }
+  int slice_size() const { return ncol(); }
+  int slice_stride() const { return ncol(); }
+  int slice_offset(int pos) const { return pos; }
+};
+
+// basic properties of matrix column slices
+template<>
+struct matrix_slices<by_column>: public matrix_dims {
+public:
+  using matrix_dims::matrix_dims;
+  using matrix_dims::nrow;
+  using matrix_dims::ncol;
+
+  int nslices() const { return ncol(); }
+  int slice_size() const { return nrow(); }
+  int slice_stride() const { return 1; }
+  int slice_offset(int pos) const { return pos * nrow(); }
+};
+
+template <typename V, typename T, typename S>
+class matrix: public matrix_slices<S> {
  private:
   V vector_;
-  int nrow_;
 
  public:
-  class row {
+
+  // matrix slice: row (if S=by_row) or a column (if S=by_column)
+  class slice {
    private:
     matrix& parent_;
-    int row_;
+    int index_;       // slice index
+    int offset_;      // index of the first element of a slice
 
    public:
-    row(matrix& parent, R_xlen_t row) : parent_(parent), row_(row) {}
-    T operator[](const int pos) { return parent_.vector_[row_ + (pos * parent_.nrow_)]; }
+    slice(matrix& parent, int index) : parent_(parent), index_(index), offset_(parent.slice_offset(index)) {}
+    inline T operator[](const int pos) const { return parent_.vector_[offset_ + stride() * pos]; }
+    inline R_xlen_t stride() const { return parent_.slice_stride(); }
+    inline R_xlen_t size() const { return parent_.slice_size(); }
+    bool operator!=(const slice& rhs) { return index_ != rhs.index_; }
 
+    // iterates elements of a slice
     class iterator {
      private:
-      row& row_;
+      slice& slice_;
       int pos_;
 
      public:
@@ -38,91 +107,71 @@ class matrix {
        using reference = T&;
        using iterator_category = std::forward_iterator_tag;
 
-      iterator(row& row, R_xlen_t pos) : row_(row), pos_(pos) {}
-      iterator begin() const { return row_.parent_.vector_iterator(&this, 0); }
-      iterator end() const { return iterator(&this, row_.size()); }
+      iterator(slice& slice, R_xlen_t pos) : slice_(slice), pos_(pos) {}
+
       inline iterator& operator++() {
         ++pos_;
         return *this;
       }
-      bool operator!=(const iterator& rhs) {
-        return !(pos_ == rhs.pos_ && row_.row_ == rhs.row_.row_);
+      inline bool operator==(const iterator& rhs) {
+        return pos_ == rhs.pos_ && slice_.index_ == rhs.slice_.index_;
+      }
+      inline bool operator!=(const iterator& rhs) {
+        return !operator==(rhs);
       }
-      T operator*() const { return row_[pos_]; };
+      T operator*() const { return slice_[pos_]; };
     };
 
     iterator begin() { return iterator(*this, 0); }
     iterator end() { return iterator(*this, size()); }
-    R_xlen_t size() const { return parent_.ncol(); }
-    bool operator!=(const row& rhs) { return row_ != rhs.row_; }
-    row& operator++() {
-      ++row_;
-      return *this;
-    }
-    row& operator*() { return *this; }
   };
-  friend row;
+  friend slice;
 
-  class column {
+  // iterates slices (rows or columns -- depending on S template param) of a matrix
+  class iterator {
    private:
-    matrix& parent_;
-    int col_;
-    int offset_;
+    matrix& matrix_;
+    int pos_;
 
    public:
-    column(matrix& parent, R_xlen_t col) : parent_(parent), col_(col), offset_(parent_.nrow() * col_) {}
-    T operator[](const int pos) { return parent_.vector_[offset_ + pos]; }
-
-    class iterator {
-     private:
-      column& col_;
-      int pos_;
-
-     public:
-      using difference_type = std::ptrdiff_t;
-      using value_type = T;
-      using pointer = T*;
-      using reference = T&;
-      using iterator_category = std::forward_iterator_tag;
-
-      iterator(column& col, R_xlen_t pos) : col_(col), pos_(pos) {}
-      iterator begin() const { return col_.parent_.vector_iterator(&this, 0); }
-      iterator end() const { return iterator(&this, col_.size()); }
-      inline iterator& operator++() {
-        ++pos_;
-        return *this;
-      }
-      bool operator!=(const iterator& rhs) {
-        return !(pos_ == rhs.pos_ && col_.col_ == rhs.col_.col_);
-      }
-      T operator*() const { return col_[pos_]; };
-    };
-
-    iterator begin() { return iterator(*this, 0); }
-    iterator end() { return iterator(*this, size()); }
-    R_xlen_t size() const { return parent_.nrow(); }
-    bool operator!=(const column& rhs) { return col_ != rhs.col_; }
-    column& operator++() {
-      ++col_;
-      return *this;
-    }
-    column& operator*() { return *this; }
+    using difference_type = std::ptrdiff_t;
+    using value_type = slice;
+    using pointer = slice*;
+    using reference = slice&;
+    using iterator_category = std::forward_iterator_tag;
+
+   iterator(matrix& matrix, R_xlen_t pos) : matrix_(matrix), pos_(pos) {}
+
+   inline iterator& operator++() {
+    ++pos_;
+    return *this;
+   }
+   inline bool operator==(const iterator& rhs) {
+    return pos_ == rhs.pos_ && (&matrix_) == (&rhs.matrix_);
+   }
+   inline bool operator!=(const iterator& rhs) {
+    return !operator==(rhs);
+   }
+   slice operator*() const { return matrix_[pos_]; };
   };
-  friend column;
+  friend iterator;
 
  public:
-  matrix(SEXP data) : vector_(data), nrow_(INTEGER_ELT(vector_.attr("dim"), 0)) {}
+  matrix(SEXP data) : matrix_slices<S>(data), vector_(data) {}
 
-  template <typename V2, typename T2>
-  matrix(const cpp11::matrix<V2, T2>& rhs) : vector_(rhs), nrow_(rhs.nrow()) {}
+  template <typename V2, typename T2, typename S2>
+  matrix(const cpp11::matrix<V2, T2, S2>& rhs) : matrix_slices<S>(rhs), vector_(rhs.vector_) {}
 
-  matrix(int nrow, int ncol) : vector_(R_xlen_t(nrow * ncol)), nrow_(nrow) {
-    vector_.attr("dim") = {nrow, ncol};
+  matrix(int nrow, int ncol) : matrix_slices<S>(nrow, ncol), vector_(R_xlen_t(nrow * ncol)) {
+    vector_.attr(R_DimSymbol) = {nrow, ncol};
   }
 
-  int nrow() const { return nrow_; }
-
-  int ncol() const { return size() / nrow_; }
+  using matrix_slices<S>::nrow;
+  using matrix_slices<S>::ncol;
+  using matrix_slices<S>::nslices;
+  using matrix_slices<S>::slice_size;
+  using matrix_slices<S>::slice_stride;
+  using matrix_slices<S>::slice_offset;
 
   SEXP data() const { return vector_.data(); }
 
@@ -140,29 +189,56 @@ class matrix {
 
   r_vector<r_string> names() const { return SEXP(vector_.names()); }
 
-  row row_at(const int pos) { return {*this, pos}; }
-  column column_at(const int pos) { return {*this, pos}; }
+  T at(int row, int col) const { return vector_[row + (col * nrow())]; }
+  T operator()(int row, int col) const { return at(row, col); }
+  slice operator[](int index) { return slice(*this, index); }
 
-  T at(int row, int col) { return vector_[row + (col * nrow_)]; }
-  T operator()(int row, int col) { return at(row, col); }
+  iterator begin() { return {*this, 0}; }
+  iterator end() { return {*this, nslices()}; }
+};
 
-  row rows_begin() { return {*this, 0}; }
-  row rows_end() { return {*this, nrow()}; }
+template<typename S>
+using doubles_matrix = matrix<r_vector<double>, double, S>;
+template<typename S>
+using integers_matrix = matrix<r_vector<int>, int, S>;
+template<typename S>
+using logicals_matrix = matrix<r_vector<r_bool>, r_bool, S>;
+template<typename S>
+using strings_matrix = matrix<r_vector<r_string>, r_string, S>;
 
-  column columns_begin() { return {*this, 0}; }
-  column columns_end() { return {*this, ncol()}; }
-};
+using doubles_row_matrix = doubles_matrix<by_row>;
+using doubles_column_matrix = doubles_matrix<by_column>;
+
+using integers_row_matrix = integers_matrix<by_row>;
+using integers_column_matrix = integers_matrix<by_column>;
+
+using logicals_row_matrix = logicals_matrix<by_row>;
+using logicals_column_matrix = logicals_matrix<by_column>;
 
-using doubles_matrix = matrix<r_vector<double>, double>;
-using integers_matrix = matrix<r_vector<int>, int>;
-using logicals_matrix = matrix<r_vector<r_bool>, r_bool>;
-using strings_matrix = matrix<r_vector<r_string>, r_string>;
+using strings_row_matrix = strings_matrix<by_row>;
+using strings_column_matrix = strings_matrix<by_column>;
 
 namespace writable {
-using doubles_matrix = matrix<r_vector<double>, r_vector<double>::proxy>;
-using integers_matrix = matrix<r_vector<int>, r_vector<int>::proxy>;
-using logicals_matrix = matrix<r_vector<r_bool>, r_vector<r_bool>::proxy>;
-using strings_matrix = matrix<r_vector<r_string>, r_vector<r_string>::proxy>;
+template<typename S>
+using doubles_matrix = matrix<r_vector<double>, r_vector<double>::proxy, S>;
+template<typename S>
+using integers_matrix = matrix<r_vector<int>, r_vector<int>::proxy, S>;
+template<typename S>
+using logicals_matrix = matrix<r_vector<r_bool>, r_vector<r_bool>::proxy, S>;
+template<typename S>
+using strings_matrix = matrix<r_vector<r_string>, r_vector<r_string>::proxy, S>;
+
+using doubles_row_matrix = doubles_matrix<by_row>;
+using doubles_column_matrix = doubles_matrix<by_column>;
+
+using integers_row_matrix = integers_matrix<by_row>;
+using integers_column_matrix = integers_matrix<by_column>;
+
+using logicals_row_matrix = logicals_matrix<by_row>;
+using logicals_column_matrix = logicals_matrix<by_column>;
+
+using strings_row_matrix = strings_matrix<by_row>;
+using strings_column_matrix = strings_matrix<by_column>;
 }  // namespace writable
 
 // TODO: Add tests for Matrix class