Working on ConstMatrixRow and ConstMatrixColumn

dcdillon · dcdillon · commit 2026aef34fa5 · 2015-11-27T08:26:15.000-06:00
diff --git a/inst/include/Rcpp/Vector.h b/inst/include/Rcpp/Vector.h
@@ -31,7 +31,9 @@ namespace Rcpp{
          template <int RTYPE, bool NA, typename VECTOR> struct Extractor ;
     }
     template <int RTYPE> class MatrixRow ;
+    template <int RTYPE> class ConstMatrixRow ;
     template <int RTYPE> class MatrixColumn ;
+    template <int RTYPE> class ConstMatrixColumn  ;
     template <int RTYPE> class SubMatrix ;
 
     class Dimension ;
diff --git a/inst/include/Rcpp/vector/Matrix.h b/inst/include/Rcpp/vector/Matrix.h
@@ -32,7 +32,9 @@ class Matrix : public Vector<RTYPE, StoragePolicy>, public MatrixBase<RTYPE, tru
     struct r_type : traits::integral_constant<int,RTYPE>{} ;
     struct can_have_na : traits::true_type{} ;
     typedef MatrixRow<RTYPE> Row ;
+    typedef ConstMatrixRow<RTYPE> ConstRow ;
     typedef MatrixColumn<RTYPE> Column ;
+    typedef ConstMatrixColumn<RTYPE> ConstColumn ;
     typedef SubMatrix<RTYPE> Sub ;
 
     typedef StoragePolicy<Matrix> Storage ;
@@ -103,7 +105,9 @@ class Matrix : public Vector<RTYPE, StoragePolicy>, public MatrixBase<RTYPE, tru
     }
 
     inline Row row( int i ){ return Row( *this, i ) ; }
+    inline ConstRow row( int i ) const{ return ConstRow( *this, i ) ; }
     inline Column column( int i ){ return Column(*this, i ) ; }
+    inline ConstColumn column( int i ) const{ return ConstColumn( *this, i ) ; }
 
     inline const_iterator begin() const{ return VECTOR::begin() ; }
     inline const_iterator end() const{ return VECTOR::end() ; }
@@ -145,11 +149,14 @@ class Matrix : public Vector<RTYPE, StoragePolicy>, public MatrixBase<RTYPE, tru
     inline Row operator()( int i, internal::NamedPlaceHolder ) {
       return Row( *this, i ) ;
     }
+    inline ConstRow operator()( int i, internal::NamedPlaceHolder ) const {
+      return ConstRow( *this, i ) ;
+    }
     inline Column operator()( internal::NamedPlaceHolder, int i ) {
       return Column( *this, i ) ;
     }
-    inline Column operator()( internal::NamedPlaceHolder, int i ) const {
-      return Column( *this, i ) ;
+    inline ConstColumn operator()( internal::NamedPlaceHolder, int i ) const {
+      return ConstColumn( *this, i ) ;
     }
     inline Sub operator()( const Range& row_range, const Range& col_range) {
       return Sub( const_cast<Matrix&>(*this), row_range, col_range ) ;
diff --git a/inst/include/Rcpp/vector/MatrixColumn.h b/inst/include/Rcpp/vector/MatrixColumn.h
@@ -103,5 +103,47 @@ class MatrixColumn : public VectorBase<RTYPE,true,MatrixColumn<RTYPE> > {
 
 } ;
 
+template <int RTYPE>
+class ConstMatrixColumn : public VectorBase<RTYPE,true,ConstMatrixColumn<RTYPE> > {
+public:
+    typedef Matrix<RTYPE> MATRIX ;
+    typedef typename MATRIX::const_Proxy const_Proxy ;
+    typedef typename MATRIX::value_type value_type ;
+    typedef typename MATRIX::const_iterator const_iterator ;
+    typedef typename const_iterator iterator;
+
+    ConstMatrixColumn( const MATRIX& parent, int i ) :
+        n(parent.nrow()),
+        const_start(parent.begin() + i *n)
+    {
+        if( i < 0 || i >= parent.ncol() ) throw index_out_of_bounds() ;
+    }
+
+    ConstMatrixColumn( const ConstMatrixColumn& other ) :
+        n(other.n),
+        const_start(other.const_start) {}
+        
+    inline const_Proxy operator[]( int i ) const {
+        return const_start[i] ;
+    }
+
+    inline const_iterator begin() const {
+        return const_start ;
+    }
+
+    inline const_iterator end() const {
+        return const_start + n ;
+    }
+
+    inline int size() const {
+        return n ;
+    }
+
+private:
+    const int n ;
+    const_iterator const_start ;
+
+} ;
+
 }
 #endif
diff --git a/inst/include/Rcpp/vector/MatrixRow.h b/inst/include/Rcpp/vector/MatrixRow.h
@@ -170,6 +170,127 @@ class MatrixRow : public VectorBase< RTYPE, true, MatrixRow<RTYPE> > {
         return i * parent_nrow ;
     }
 } ;
+
+template <int RTYPE>
+class ConstMatrixRow : public VectorBase< RTYPE, true, ConstMatrixRow<RTYPE> > {
+public:
+    typedef Matrix<RTYPE> MATRIX ;
+    typedef typename MATRIX::const_Proxy const_reference ;
+    typedef typename MATRIX::value_type value_type ;
+
+    class const_iterator {
+    public:
+        typedef typename traits::r_vector_iterator<RTYPE>::type vector_iterator ;
+
+        typedef int difference_type ;
+        typedef typename traits::r_vector_const_proxy<RTYPE>::type value_type ;
+        typedef typename traits::r_vector_const_proxy<RTYPE>::type reference ;
+        typedef typename std::iterator_traits<vector_iterator>::pointer pointer ;
+
+        typedef std::random_access_iterator_tag iterator_category ;
+
+        const_iterator( const const_iterator& other) : row(other.row), index(other.index){}
+        const_iterator( const ConstMatrixRow& row_, int index_ ) : row(row_), index(index_){}
+
+        const_iterator& operator++(){
+            index++;
+            return *this ;
+        }
+        const_iterator operator++(int) {
+            const_iterator orig(*this);
+            index++ ;
+            return orig ;
+        }
+
+        const_iterator& operator--(){
+            index-- ;
+            return *this ;
+        }
+        const_iterator operator--(int){
+            const_iterator orig(*this);
+            index-- ;
+            return orig ;
+        }
+
+        const_iterator operator+(difference_type n) const { return iterator( row, index + n ) ; }
+        const_iterator operator-(difference_type n) const { return iterator( row, index - n ) ; }
+        difference_type operator-(const const_iterator& other) const { return index - other.index ; }
+
+        const_iterator& operator+=(difference_type n) { index += n ; return *this ;}
+        const_iterator& operator-=(difference_type n) { index -= n ; return *this ;}
+
+        const reference operator*() {
+            return row[index] ;
+        }
+        const pointer operator->(){
+            return &row[index] ;
+        }
+
+        bool operator==( const const_iterator& other) { return index == other.index ; }
+        bool operator!=( const const_iterator& other) { return index != other.index ; }
+        bool operator<( const const_iterator& other ) { return index < other.index ;}
+        bool operator>( const const_iterator& other ) { return index > other.index ;}
+        bool operator<=( const const_iterator& other ) { return index <= other.index ; }
+        bool operator>=( const const_iterator& other ) { return index >= other.index ; }
+
+        inline const reference operator[]( int i) const {
+            return row[ index + i ] ;
+        }
+
+        difference_type operator-(const const_iterator& other) {
+            return index - other.index ;
+        }
+
+    private:
+        const ConstMatrixRow& row ;
+        int index ;
+    } ;
+    
+    typedef const_iterator iterator;
+
+    ConstMatrixRow( const MATRIX& object, int i ) :
+        parent(object),
+        start(parent.begin() + i),
+        parent_nrow(parent.nrow()),
+        row(i)
+    {
+        if( i < 0 || i >= parent.nrow() ) throw index_out_of_bounds() ;
+    }
+
+    ConstMatrixRow( const ConstMatrixRow& other ) :
+        parent(other.parent),
+        start(other.start),
+        parent_nrow(other.parent_nrow),
+        row(other.row)
+    {} ;
+
+    inline const_reference operator[]( int i ) const {
+        return parent[ row + i * parent_nrow ] ;
+    }
+
+    inline const_iterator begin() const {
+        return const_iterator( *this, 0 ) ;
+    }
+
+    inline const_iterator end() const {
+        return const_iterator( *this, size() ) ;
+    }
+
+    inline int size() const {
+        return parent.ncol() ;
+    }
+
+private:
+    const MATRIX& parent;
+    typename MATRIX::const_iterator start ;
+    int parent_nrow ;
+    int row ;
+
+    inline int get_parent_index(int i) const {
+        RCPP_DEBUG_4( "ConstMatrixRow<%d>::get_parent_index(int = %d), parent_nrow = %d >> %d\n", RTYPE, i, parent_nrow, i*parent_nrow )
+        return i * parent_nrow ;
+    }
+} ;
 }
 
 #endif
diff --git a/inst/unitTests/cpp/Matrix.cpp b/inst/unitTests/cpp/Matrix.cpp
@@ -99,6 +99,12 @@ double runit_NumericMatrix_row( NumericMatrix m){
     return std::accumulate( first_row.begin(), first_row.end(), 0.0 ) ;
 }
 
+// [[Rcpp::export]]
+double runit_NumericMatrix_row_const( const NumericMatrix m){
+    NumericMatrix::ConstRow first_row = m.row(0) ;
+    return std::accumulate( first_row.begin(), first_row.end(), 0.0 ) ;
+}
+
 // [[Rcpp::export]]
 std::string runit_CharacterMatrix_row( CharacterMatrix m ){
     CharacterMatrix::Row first_row = m.row(0) ;
@@ -108,6 +114,15 @@ std::string runit_CharacterMatrix_row( CharacterMatrix m ){
     return res ;
 }
 
+// [[Rcpp::export]]
+std::string runit_CharacterMatrix_row_const( const CharacterMatrix m ){
+    CharacterMatrix::ConstRow first_row = m.row(0) ;
+    std::string res(
+    	std::accumulate(
+    		first_row.begin(), first_row.end(), std::string() ) ) ;
+    return res ;
+}
+
 // [[Rcpp::export]]
 IntegerVector runit_GenericMatrix_row( GenericMatrix m ){
     GenericMatrix::Row first_row = m.row(0) ;
@@ -119,12 +134,29 @@ IntegerVector runit_GenericMatrix_row( GenericMatrix m ){
     return out ;
 }
 
+// [[Rcpp::export]]
+IntegerVector runit_GenericMatrix_row_const( const GenericMatrix m ){
+    GenericMatrix::ConstRow first_row = m.row(0) ;
+    IntegerVector out( first_row.size() ) ;
+    std::transform(
+    	first_row.begin(), first_row.end(),
+    	out.begin(),
+    	unary_call<SEXP,int>( Function("length" ) ) ) ;
+    return out ;
+}
+
 // [[Rcpp::export]]
 double runit_NumericMatrix_column( NumericMatrix m ){
     NumericMatrix::Column col = m.column(0) ;
     return std::accumulate( col.begin(), col.end(), 0.0 ) ;
 }
 
+// [[Rcpp::export]]
+double runit_NumericMatrix_column_const( const NumericMatrix m ){
+    NumericMatrix::ConstColumn col = m.column(0) ;
+    return std::accumulate( col.begin(), col.end(), 0.0 ) ;
+}
+
 // [[Rcpp::export]]
 NumericMatrix runit_NumericMatrix_cumsum( NumericMatrix input ){
     int nr = input.nrow(), nc = input.ncol() ;
@@ -147,6 +179,15 @@ std::string runit_CharacterMatrix_column( CharacterMatrix m){
     return res ;
 }
 
+// [[Rcpp::export]]
+std::string runit_CharacterMatrix_column_const( const CharacterMatrix m){
+    CharacterMatrix::ConstColumn col = m.column(0) ;
+    std::string res(
+        std::accumulate( col.begin(), col.end(), std::string() )
+    ) ;
+    return res ;
+}
+
 // [[Rcpp::export]]
 IntegerVector runit_GenericMatrix_column( GenericMatrix m ){
     GenericMatrix::Column col = m.column(0) ;
@@ -159,6 +200,18 @@ IntegerVector runit_GenericMatrix_column( GenericMatrix m ){
     return wrap(out) ;
 }
 
+// [[Rcpp::export]]
+IntegerVector runit_GenericMatrix_column_const( const GenericMatrix m ){
+    GenericMatrix::ConstColumn col = m.column(0) ;
+    IntegerVector out( col.size() ) ;
+    std::transform(
+    	   col.begin(), col.end(),
+    	   out.begin(),
+    	   unary_call<SEXP,int>( Function("length" ) )
+    ) ;
+    return wrap(out) ;
+}
+
 // [[Rcpp::export]]
 List runit_Row_Column_sugar( NumericMatrix x){
     NumericVector r0 = x.row(0) ;
diff --git a/inst/unitTests/runit.Matrix.R b/inst/unitTests/runit.Matrix.R
@@ -94,22 +94,43 @@ if (.runThisTest) {
 	checkEquals( runit_NumericMatrix_row( x ), sum( x[1,] ), msg = "iterating over a row" )
     }
 
+    test.NumericMatrix.row.const <- function(){
+	x <- matrix( 1:16 + .5, ncol = 4 )
+	checkEquals( runit_NumericMatrix_row_const( x ), sum( x[1,] ), msg = "iterating over a row" )
+    }
+
     test.CharacterMatrix.row <- function(){
 	m <- matrix( letters, ncol = 2 )
 	checkEquals( runit_CharacterMatrix_row(m), paste( m[1,], collapse = "" ), msg = "CharacterVector::Row" )
     }
 
+    test.CharacterMatrix.row.const <- function(){
+	m <- matrix( letters, ncol = 2 )
+	checkEquals( runit_CharacterMatrix_row_const(m), paste( m[1,], collapse = "" ), msg = "CharacterVector::Row" )
+    }
+
     test.List.row <- function(){
 	m <- lapply( 1:16, function(i) seq(from=1, to = i ) )
 	dim( m ) <- c( 4, 4 )
 	checkEquals( runit_GenericMatrix_row( m ), 1 + 0:3*4, msg = "List::Row" )
     }
 
+    test.List.row.const <- function(){
+	m <- lapply( 1:16, function(i) seq(from=1, to = i ) )
+	dim( m ) <- c( 4, 4 )
+	checkEquals( runit_GenericMatrix_row_const( m ), 1 + 0:3*4, msg = "List::Row" )
+    }
+
     test.NumericMatrix.column <- function(){
 	x <- matrix( 1:16 + .5, ncol = 4 )
 	checkEquals( runit_NumericMatrix_column( x ), sum( x[,1] ) , msg = "iterating over a column" )
     }
 
+    test.NumericMatrix.column.const <- function(){
+	x <- matrix( 1:16 + .5, ncol = 4 )
+	checkEquals( runit_NumericMatrix_column_const( x ), sum( x[,1] ) , msg = "iterating over a column" )
+    }
+
     test.NumericMatrix.cumsum <- function(){
 	x <- matrix( 1:8 + .5, ncol = 2 )
 	checkEquals( runit_NumericMatrix_cumsum( x ), t(apply(x, 1, cumsum)) , msg = "cumsum" )
@@ -120,12 +141,23 @@ if (.runThisTest) {
 	checkEquals( runit_CharacterMatrix_column(m), paste( m[,1], collapse = "" ), msg = "CharacterVector::Column" )
     }
 
+    test.CharacterMatrix.column.const <- function(){
+	m <- matrix( letters, ncol = 2 )
+	checkEquals( runit_CharacterMatrix_column_const(m), paste( m[,1], collapse = "" ), msg = "CharacterVector::Column" )
+    }
+
     test.List.column <- function(){
 	m <- lapply( 1:16, function(i) seq(from=1, to = i ) )
 	dim( m ) <- c( 4, 4 )
 	checkEquals( runit_GenericMatrix_column( m ), 1:4, msg = "List::Column" )
     }
 
+    test.List.column.const <- function(){
+	m <- lapply( 1:16, function(i) seq(from=1, to = i ) )
+	dim( m ) <- c( 4, 4 )
+	checkEquals( runit_GenericMatrix_column_const( m ), 1:4, msg = "List::Column" )
+    }
+
     test.NumericMatrix.colsum <- function( ){
         probs <- matrix(1:12,nrow=3)
         checkEquals( runit_NumericMatrix_colsum( probs ), t(apply(probs,1,cumsum)) )

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,9 @@ namespace Rcpp{`
`31`	`31`	`template <int RTYPE, bool NA, typename VECTOR> struct Extractor ;`
`32`	`32`	`}`
`33`	`33`	`template <int RTYPE> class MatrixRow ;`
	`34`	`+ template <int RTYPE> class ConstMatrixRow ;`
`34`	`35`	`template <int RTYPE> class MatrixColumn ;`
	`36`	`+ template <int RTYPE> class ConstMatrixColumn ;`
`35`	`37`	`template <int RTYPE> class SubMatrix ;`
`36`	`38`
`37`	`39`	`class Dimension ;`