Add basic iterator for matrices

This implements only enough for range based for loops

Fixes #41

Author: jimhester

cpp11test/R/cpp11.R

@@ -56,6 +56,10 @@ gibbs_rcpp2 <- function(N, thin) {
   .Call("_cpp11test_gibbs_rcpp2", N, thin)
 }
 
+row_sums <- function(x) {
+  .Call("_cpp11test_row_sums", x)
+}
+
 protect_one_ <- function(x, n) {
   invisible(.Call("_cpp11test_protect_one_", x, n))
 }

cpp11test/src/cpp11.cpp

@@ -103,6 +103,13 @@ extern "C" SEXP _cpp11test_gibbs_rcpp2(SEXP N, SEXP thin) {
     return cpp11::as_sexp(gibbs_rcpp2(cpp11::unmove(cpp11::as_cpp<int>(N)), cpp11::unmove(cpp11::as_cpp<int>(thin))));
   END_CPP11
 }
+// matrix.cpp
+cpp11::doubles row_sums(cpp11::doubles_matrix x);
+extern "C" SEXP _cpp11test_row_sums(SEXP x) {
+  BEGIN_CPP11
+    return cpp11::as_sexp(row_sums(cpp11::unmove(cpp11::as_cpp<cpp11::doubles_matrix>(x))));
+  END_CPP11
+}
 // protect.cpp
 void protect_one_(SEXP x, int n);
 extern "C" SEXP _cpp11test_protect_one_(SEXP x, SEXP n) {
@@ -314,6 +321,7 @@ extern SEXP _cpp11test_rcpp_sum_dbl_accumulate_(SEXP);
 extern SEXP _cpp11test_rcpp_sum_dbl_for_(SEXP);
 extern SEXP _cpp11test_rcpp_sum_dbl_foreach_(SEXP);
 extern SEXP _cpp11test_remove_altrep(SEXP);
+extern SEXP _cpp11test_row_sums(SEXP);
 extern SEXP _cpp11test_sum_dbl_accumulate_(SEXP);
 extern SEXP _cpp11test_sum_dbl_accumulate2_(SEXP);
 extern SEXP _cpp11test_sum_dbl_for_(SEXP);
@@ -355,6 +363,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"_cpp11test_rcpp_sum_dbl_for_",        (DL_FUNC) &_cpp11test_rcpp_sum_dbl_for_,        1},
     {"_cpp11test_rcpp_sum_dbl_foreach_",    (DL_FUNC) &_cpp11test_rcpp_sum_dbl_foreach_,    1},
     {"_cpp11test_remove_altrep",            (DL_FUNC) &_cpp11test_remove_altrep,            1},
+    {"_cpp11test_row_sums",                 (DL_FUNC) &_cpp11test_row_sums,                 1},
     {"_cpp11test_sum_dbl_accumulate_",      (DL_FUNC) &_cpp11test_sum_dbl_accumulate_,      1},
     {"_cpp11test_sum_dbl_accumulate2_",     (DL_FUNC) &_cpp11test_sum_dbl_accumulate2_,     1},
     {"_cpp11test_sum_dbl_for_",             (DL_FUNC) &_cpp11test_sum_dbl_for_,             1},

cpp11test/src/matrix.cpp

@@ -66,3 +66,21 @@ using namespace Rcpp;
 
   return (mat);
 }
+
+[[cpp11::register]] cpp11::doubles row_sums(cpp11::doubles_matrix x) {
+  cpp11::writable::doubles sums(x.nrow());
+
+  int i = 0;
+  for (auto& row : x) {
+    for (auto&& val : row) {
+      if (cpp11::is_na(val)) {
+        sums[i] = NA_REAL;
+        break;
+      }
+      sums[i] += val;
+    }
+    ++i;
+  }
+
+  return sums;
+}

cpp11test/tests/testthat/test-matrix.R

@@ -0,0 +1,9 @@
+test_that("row_sums gives same result as rowSums", {
+  x <- cbind(x1 = 3, x2 = c(4:1, 2:5))
+  expect_equal(row_sums(x), rowSums(x))
+
+  # With missing values
+  y <- cbind(x1 = 3, x2 = c(4:1, 2:5))
+  y[3, ] <- NA; x[4, 2] <- NA
+  expect_equal(row_sums(x), rowSums(x))
+})

inst/include/cpp11/matrix.hpp

@@ -10,6 +10,7 @@ class matrix {
   V vector_;
   int nrow_;
 
+ public:
   class row {
    private:
     matrix& parent_;
@@ -18,6 +19,35 @@ class matrix {
    public:
     row(matrix& parent, R_xlen_t row) : parent_(parent), row_(row) {}
     T operator[](const int pos) { return parent_.vector_[row_ + (pos * parent_.nrow_)]; }
+
+    class iterator {
+     private:
+      row& row_;
+      int pos_;
+
+     public:
+      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()); }
+      inline iterator& operator++() {
+        ++pos_;
+        return *this;
+      }
+      bool operator!=(const iterator& rhs) {
+        return !(pos_ == rhs.pos_ && row_.row_ == rhs.row_.row_);
+      }
+      T operator*() const { return row_[pos_]; };
+    };
+
+    iterator begin() { return iterator(*this, 0); }
+    iterator end() { return iterator(*this, size()); }
+    R_xlen_t size() const { return parent_.vector_.size() / parent_.nrow_; }
+    bool operator!=(const row& rhs) { return row_ != rhs.row_; }
+    row& operator++() {
+      ++row_;
+      return *this;
+    }
+    row& operator*() { return *this; }
   };
   friend row;
 
@@ -55,7 +85,8 @@ class matrix {
 
   T operator()(int row, int col) { return vector_[row + (col * nrow_)]; }
 
-  // operator cpp11::matrix<V, T>() { return SEXP(); }
+  row begin() { return {*this, 0}; }
+  row end() { return {*this, nrow_}; }
 };
 
 using doubles_matrix = matrix<r_vector<double>, double>;
@@ -71,5 +102,4 @@ using strings_matrix = matrix<r_vector<r_string>, r_vector<r_string>::proxy>;
 }  // namespace writable
 
 // TODO: Add tests for Matrix class
-
 };  // namespace cpp11