maybe #111

Author: romainfrancois

inst/include/Rcpp/api/meat/Matrix.h

@@ -34,7 +34,6 @@
 #include <Rcpp/api/meat/DottedPairImpl.h>
 #include <Rcpp/api/meat/StretchyList.h>
 #include <Rcpp/api/meat/Vector.h>
-#include <Rcpp/api/meat/Matrix.h>
 #include <Rcpp/api/meat/is.h>
 #include <Rcpp/api/meat/as.h>
 #include <Rcpp/api/meat/export.h>

inst/include/Rcpp/api/meat/meat.h

@@ -2,7 +2,7 @@
 //
 // Matrix.h: Rcpp R/C++ interface class library -- matrices
 //
-// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2010 - 2014 Dirk Eddelbuettel and Romain Francois
 //
 // This file is part of Rcpp.
 //
@@ -45,23 +45,43 @@ class Matrix : public Vector<RTYPE, StoragePolicy>, public MatrixBase<RTYPE, tru
 
     Matrix() : VECTOR() {}
 
-    Matrix(SEXP x) ;
+    Matrix(SEXP x) : VECTOR( r_cast<RTYPE>( x ) ), nrows( VECTOR::dims()[0] ) {}
 
-    Matrix( const int& n) ; 
-    Matrix( const Dimension& dims)  ;
-    Matrix( const int& nrows_, const int& ncols)  ;
+    Matrix( const Dimension& dims) : VECTOR( Rf_allocMatrix( RTYPE, dims[0], dims[1] ) ), nrows(dims[0]) {
+        if( dims.size() != 2 ) throw not_compatible("not a matrix") ;
+        VECTOR::init() ;
+    }
+    Matrix( const int& nrows_, const int& ncols) : VECTOR( Dimension( nrows_, ncols ) ),
+        nrows(nrows_)
+    {}
 
     template <typename Iterator>
-    Matrix( const int& nrows_, const int& ncols, Iterator start ) ;
+    Matrix( const int& nrows_, const int& ncols, Iterator start ) :
+        VECTOR( start, start + (nrows_*ncols) ),
+        nrows(nrows_)
+    {
+        VECTOR::attr( "dim" ) = Dimension( nrows, ncols ) ;
+    }
+    
+    Matrix( const int& n) : VECTOR( Dimension( n, n ) ), nrows(n) {}
+    
 
-    Matrix( const Matrix& other)  ;
+    Matrix( const Matrix& other) : VECTOR( other.get__() ), nrows(other.nrows) {}
 
     template <bool NA, typename MAT>
-    Matrix( const MatrixBase<RTYPE,NA,MAT>& other )  ;
+    Matrix( const MatrixBase<RTYPE,NA,MAT>& other ) : VECTOR( Rf_allocMatrix( RTYPE, other.nrow(), other.ncol() ) ), nrows(other.nrow()) {
+        import_matrix_expression<NA,MAT>( other, nrows, ncol() ) ;
+    }
 
     Matrix( const SubMatrix<RTYPE>& ) ;
 
-    Matrix& operator=(const Matrix& other)  ;
+    Matrix& operator=(const Matrix& other) {
+        SEXP x = other.get__() ;
+        if( ! ::Rf_isMatrix(x) ) not_compatible("not a matrix") ;
+        VECTOR::set__( x ) ;
+        nrows = other.nrows ;
+        return *this ;
+    }
     Matrix& operator=( const SubMatrix<RTYPE>& ) ;
 
     inline int ncol() const {
@@ -85,36 +105,88 @@ class Matrix : public Vector<RTYPE, StoragePolicy>, public MatrixBase<RTYPE, tru
     inline iterator begin() { return VECTOR::begin() ; }
     inline iterator end() { return VECTOR::end() ; }
 
-    template <typename U> void fill_diag( const U& u) ;
+    template <typename U> 
+    void fill_diag( const U& u) {
+      fill_diag__dispatch( typename traits::is_trivial<RTYPE>::type(), u ) ;
+    }
 
-    template <typename U> static Matrix diag( int size, const U& diag_value ) ;
+    template <typename U> static Matrix diag( int size, const U& diag_value ) {
+      Matrix res(size,size) ;
+        res.fill_diag( diag_value ) ;
+        return res ;
+    }
 
-    inline Proxy operator[]( int i ) ;
-    inline const_Proxy operator[]( int i ) const  ;
+    inline Proxy operator[]( int i ) {
+      return static_cast< Vector<RTYPE>* >( this )->operator[]( i ) ;
+    }
+    inline const_Proxy operator[]( int i ) const {
+      return static_cast< const Vector<RTYPE>* >( this )->operator[]( i ) ;
+    }
 
-    inline Proxy operator()( const size_t& i, const size_t& j) ; 
-    inline const_Proxy operator()( const size_t& i, const size_t& j) const  ;
+    inline Proxy operator()( const size_t& i, const size_t& j) {
+      return static_cast< Vector<RTYPE>* >( this )->operator[]( offset( i, j ) ) ;
+    }
+    inline const_Proxy operator()( const size_t& i, const size_t& j) const {
+       return static_cast< const Vector<RTYPE>* >( this )->operator[]( offset( i, j ) ) ; 
+    }
 
-    inline Row operator()( int i, internal::NamedPlaceHolder ) ;
-    inline Column operator()( internal::NamedPlaceHolder, int i ) ;
-    inline Column operator()( internal::NamedPlaceHolder, int i ) const  ;
-    inline Sub operator()( const Range& row_range, const Range& col_range) ;        
-    inline Sub operator()( internal::NamedPlaceHolder, const Range& col_range) ;
-    inline Sub operator()( const Range& row_range, internal::NamedPlaceHolder ) ;
+    inline Row operator()( int i, internal::NamedPlaceHolder ) {
+      return Row( *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 Sub operator()( const Range& row_range, const Range& col_range) {
+      return Sub( const_cast<Matrix&>(*this), row_range, col_range ) ;
+    }
+    inline Sub operator()( internal::NamedPlaceHolder, const Range& col_range) {
+      return Sub( const_cast<Matrix&>(*this), Range(0,nrow()-1) , col_range ) ;  
+    }
+    inline Sub operator()( const Range& row_range, internal::NamedPlaceHolder ) {
+      return Sub( const_cast<Matrix&>(*this), row_range, Range(0,ncol()-1) ) ;  
+    }
 
 
 private:
 
     inline int offset( int i, int j) const { return i + nrows * j ; }
 
     template <typename U>
-    void fill_diag__dispatch( traits::false_type, const U& u) ;
+    void fill_diag__dispatch( traits::false_type, const U& u) {
+          Shield<SEXP> elem( converter_type::get( u ) ) ;
+        int n = Matrix::ncol() ;
+        int offset = n +1 ;
+        iterator it( VECTOR::begin()) ;
+        for( int i=0; i<n; i++){
+            *it = ::Rf_duplicate( elem );
+            it += offset;
+        }
+    }
 
     template <typename U>
-    void fill_diag__dispatch( traits::true_type, const U& u) ;
+    void fill_diag__dispatch( traits::true_type, const U& u) {
+          stored_type elem = converter_type::get( u ) ;
+        int n = Matrix::ncol() ;
+        int offset = n + 1 ;
+        iterator it( VECTOR::begin()) ;
+        for( int i=0; i<n; i++){
+            *it = elem ;
+            it += offset;
+        }
+    }
 
     template <bool NA, typename MAT>
-    void import_matrix_expression( const MatrixBase<RTYPE,NA,MAT>& other, int nr, int nc ) ;
+    void import_matrix_expression( const MatrixBase<RTYPE,NA,MAT>& other, int nr, int nc ) {
+      iterator start = VECTOR::begin() ;
+        for( int j=0; j<nc; j++){
+            for( int i=0; i<nr; i++, ++start){
+                *start = other(i,j) ;
+            }
+        }  
+    }
 
 } ;