close #365

Author: Qiang Kou

ChangeLog

@@ -1,3 +1,9 @@
+2015-12-04  Qiang Kou <[email protected]>
+
+        * inst/include/Rcpp/vector/Matrix.h: Add math operators between matrix and scalar
+        * inst/unitTests/runit.Matrix.R: Unit tests
+        * inst/unitTests/cpp/Matrix.cpp: Unit tests
+
 2015-11-27  JJ Allaire <[email protected]>
 
         * src/attributes.cpp: Avoid invalid function names when

inst/include/Rcpp/vector/Matrix.h

@@ -247,6 +247,39 @@ inline std::ostream &operator<<(std::ostream & s, const Matrix<REALSXP, StorageP
     return s;
 }
 
+#define RCPP_GENERATE_MATRIX_SCALAR_OPERATOR(__OPERATOR__)                                                                    \
+    template <int RTYPE, template <class> class StoragePolicy >                                                               \
+    inline Matrix<RTYPE, StoragePolicy> operator __OPERATOR__ (const Matrix<RTYPE, StoragePolicy> &lhs,                       \
+        const typename Matrix<RTYPE, StoragePolicy>::stored_type &rhs) {                                                      \
+        Vector<RTYPE, StoragePolicy> v = static_cast<const Vector<RTYPE, StoragePolicy> &>(lhs) __OPERATOR__ rhs;             \
+        v.attr("dim") = Vector<INTSXP>::create(lhs.nrow(), lhs.ncol());                                                       \
+        return as< Matrix<RTYPE, StoragePolicy> >(v);                                                                         \
+    }
+
+RCPP_GENERATE_MATRIX_SCALAR_OPERATOR(+)
+RCPP_GENERATE_MATRIX_SCALAR_OPERATOR(-)
+RCPP_GENERATE_MATRIX_SCALAR_OPERATOR(*)
+RCPP_GENERATE_MATRIX_SCALAR_OPERATOR(/)
+
+#undef RCPP_GENERATE_MATRIX_SCALAR_OPERATOR
+
+#define RCPP_GENERATE_SCALAR_MATRIX_OPERATOR(__OPERATOR__)                                                                    \
+    template <int RTYPE, template <class> class StoragePolicy >                                                               \
+    inline Matrix<RTYPE, StoragePolicy> operator __OPERATOR__ (const typename Matrix<RTYPE, StoragePolicy>::stored_type &lhs, \
+        const Matrix<RTYPE, StoragePolicy> &rhs) {                                                                            \
+        Vector<RTYPE, StoragePolicy> v = static_cast<const Vector<RTYPE, StoragePolicy> &>(rhs);                              \
+        v = lhs __OPERATOR__ v;                                                                                               \
+        v.attr("dim") = Vector<INTSXP>::create(rhs.nrow(), rhs.ncol());                                                       \
+        return as< Matrix<RTYPE, StoragePolicy> >(v);                                                                         \
+    }
+
+RCPP_GENERATE_SCALAR_MATRIX_OPERATOR(+)
+RCPP_GENERATE_SCALAR_MATRIX_OPERATOR(-)
+RCPP_GENERATE_SCALAR_MATRIX_OPERATOR(*)
+RCPP_GENERATE_SCALAR_MATRIX_OPERATOR(/)
+
+#undef RCPP_GENERATE_SCALAR_MATRIX_OPERATOR
+
 template<template <class> class StoragePolicy >
 inline std::ostream &operator<<(std::ostream & s, const Matrix<INTSXP, StoragePolicy> & rhs) {
     typedef Matrix<INTSXP, StoragePolicy> MATRIX;

inst/unitTests/cpp/Matrix.cpp

@@ -311,3 +311,23 @@ NumericMatrix transposeNumeric(const NumericMatrix & x) {
 CharacterMatrix transposeCharacter(const CharacterMatrix & x) {
     return transpose(x);
 }
+
+// [[Rcpp::export]]
+NumericMatrix matrix_scalar_plus(const NumericMatrix & x, int y) {
+    return x + y;
+}
+
+// [[Rcpp::export]]
+NumericMatrix matrix_scalar_plus2(const NumericMatrix & x, int y) {
+    return y + x;
+}
+
+// [[Rcpp::export]]
+NumericMatrix matrix_scalar_divide(const NumericMatrix & x, int y) {
+    return x / y;
+}
+
+// [[Rcpp::export]]
+NumericMatrix matrix_scalar_divide2(const NumericMatrix & x, int y) {
+    return y / x;
+}

inst/unitTests/runit.Matrix.R

@@ -242,4 +242,11 @@ if (.runThisTest) {
         checkEquals(transposeCharacter(M), t(M), msg="character transpose with row and colnames")
     }
 
+    test.Matrix.Scalar.op <- function() {
+        M <- matrix(c(1:12), 3, 4)
+        checkEquals(matrix_scalar_plus(M, 2), M + 2, msg="matrix + scalar")
+        checkEquals(matrix_scalar_plus2(M, 2), 2 + M, msg="scalar + matrix")
+        checkEquals(matrix_scalar_divide(M, 2), M / 2, msg="matrix / scalar")
+        checkEquals(matrix_scalar_divide2(M, 2), 2 / M, msg="scalar / matrix")
+    }
 }