Merge branch 'master' of https://github.com/Rcpp11/Rcpp11

romainfrancois · romainfrancois · commit 5ff210bf3fea · 2015-07-04T10:13:40.000+02:00
diff --git a/.travis.yml b/.travis.yml
@@ -7,9 +7,9 @@ before_install:
   - ./travis-tool.sh github_package hadley/testthat
   - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
   - sudo apt-get -qq update
-  - sudo apt-get -qq install g++-4.8     
+  - sudo apt-get -qq install g++-4.9     
   - mkdir ~/.R
-  - echo -e "CC=gcc-4.8 -std=gnu99\nCXX=g++-4.8 -std=c++11\nnCXX1X=g++-4.8\nCXXFLAGS=-g -O3\nCXX1XFLAGS=-g -O3\nCFLAGS=-g -O3\n" > ~/.R/Makevars
+  - echo -e "CC=gcc-4.9 -std=gnu99\nCXX=g++-4.9 -std=c++11\nnCXX1X=g++-4.9\nCXXFLAGS=-g -O3\nCXX1XFLAGS=-g -O3\nCFLAGS=-g -O3\n" > ~/.R/Makevars
   
 script:
   - R CMD INSTALL .
diff --git a/DESCRIPTION b/DESCRIPTION
@@ -1,15 +1,15 @@
 Package: Rcpp11
 Title: R and C++11
-Version: 3.1.1.0.999
-Date: 2014-07-22
+Version: 3.1.2.0.1
+Date: 2014-11-10
 Authors@R: c(
     person("Romain", "Francois", role = c("aut", "cre"), email = "romain@r-enthusiasts.com"),
     person("Kevin", "Ushey", role = "aut", email = "kevinushey@gmail.com"),
     person("John", "Chambers", role = "ctb", email = "jmc@r-project.org")
     )
 Description: Rcpp11 includes a header only C++11 library that facilitates 
   integration between R and modern C++. 
-Depends: R (>= 3.1.1)
+Depends: R (>= 3.1.2)
 License: MIT + file LICENSE
 SystemRequirements: C++11
 
diff --git a/NEWS.md b/NEWS.md
@@ -1,7 +1,27 @@
+# Rcpp11 3.2.0
+
+* `rownames` setter and getter for `DataFrame` (#210)
+
+* Added `operator+=`, `-=`, `*=` and `/=` where the rhs is a sugar expression. 
+
+* Added template class `Strict` to implement more rigid (no automatic coercion) 
+  arguments in attribute generated functions. 
+  
+* Added `operator+=` etc ... for `Vector` x `primitive` case.   
+
+* Added `operator+=` etc ... for `Matrix` x `primitive` case. 
+
 # Rcpp11 3.1.2
 
 * New `wrap` implementation for `std::tuple<Args...>` (#195)
 
+* `colnames` and `rownames` setters for matrices (#210). 
+
+* Most sugar functions are now processing the expression in parallel. 
+
+* Forbidden symbols from the C/R API are no longer directly used, so packages can 
+  use Rcpp11 without getting the NOTE as before. 
+
 # Rcpp11 3.1.1
 
 * sugar `sum` now supports complex sugar vector expressions
diff --git a/inst/include/Rcpp.h b/inst/include/Rcpp.h
@@ -117,7 +117,8 @@ namespace Rcpp{
 
     template <int RTYPE, typename Storage = PreserveStorage> class Vector ;
     template <int RTYPE, typename Storage = PreserveStorage> class Matrix ;
-
+    template <int RTYPE, typename Storage = PreserveStorage> class SquareMatrix ;
+    
     typedef Vector<STRSXP> CharacterVector ;
     typedef Vector<VECSXP> List ;
     typedef Vector<EXPRSXP> ExpressionVector ;
@@ -183,8 +184,7 @@ namespace Rcpp{
 #include <Rcpp/proxy/proxy.h>
 #include <Rcpp/Symbol.h>
 
-#include <Rcpp/storage/PreserveStorage.h>
-#include <Rcpp/storage/NoProtectStorage.h>
+#include <Rcpp/storage/storage.h>
 
 #include <Rcpp/Node.h>
 #include <Rcpp/grow.h>
@@ -234,6 +234,9 @@ namespace Rcpp{
 
 #include <Rcpp/Timer.h>
 
+#include <Rcpp/vector/dimnames.h>
+#include <Rcpp/Strict.h>
+
 namespace Rcpp11 = Rcpp ;
 
 #endif
diff --git a/inst/include/Rcpp/Array.h b/inst/include/Rcpp/Array.h
@@ -51,6 +51,10 @@ namespace Rcpp{
             return *this ;
         }
         
+        inline int get_dim(int i) const {
+            return index.get_dim(i) ;        
+        }
+        
     private:
         Index<N> index ;
         Vec data ;
diff --git a/inst/include/Rcpp/Index.h b/inst/include/Rcpp/Index.h
@@ -42,7 +42,13 @@ namespace Rcpp{
             return dimensions[i] ;
         }
         
-        inline typename std::array<size_t,N>::iterator begin(){ return dimensions.begin() ; }
+        inline typename std::array<int,N>::iterator begin(){ 
+            return dimensions.begin() ; 
+        }
+        
+        inline int get_dim(int i) const {
+            return dimensions[i] ;    
+        }
         
     private:
         
diff --git a/inst/include/Rcpp/Strict.h b/inst/include/Rcpp/Strict.h
@@ -0,0 +1,26 @@
+#ifndef RCPP11_Strict_H
+#define RCPP11_Strict_H
+
+namespace Rcpp {
+
+    template <typename Class>
+    class Strict {
+    public:
+        Strict( SEXP x ) : obj(x){
+            if( !is<Class>(x) ){
+                stop( "not compatible with class %s", DEMANGLE(Class) ) ;    
+            }
+        }
+        
+        inline Class get() const {
+            return Class(obj) ;    
+        }
+        
+    private:
+        SEXP obj ;
+    } ;
+    
+}
+
+#endif
+
diff --git a/inst/include/Rcpp/Vector.h b/inst/include/Rcpp/Vector.h
@@ -33,5 +33,6 @@
 #include <Rcpp/vector/MatrixColumn.h>
 #include <Rcpp/vector/MatrixRow.h>
 #include <Rcpp/vector/Matrix.h>
+#include <Rcpp/vector/SquareMatrix.h>
 
 #endif
diff --git a/inst/include/Rcpp/sugar/functions/unique.h b/inst/include/Rcpp/sugar/functions/unique.h
@@ -5,14 +5,14 @@ namespace Rcpp{
 
     template <typename eT, typename Expr>
     inline typename traits::vector_of<eT>::type unique( const SugarVectorExpression<eT, Expr>& t ){
-        std::unordered_set<eT> set( t.begin(), t.end() ) ;
+        std::unordered_set<eT> set( sugar_begin(t), sugar_end(t) ) ;
         return import( set.begin(), set.end() ) ;
     }
     
     template <typename eT, typename Expr1, typename Expr2>
     inline LogicalVector in( const SugarVectorExpression<eT, Expr1>& x, const SugarVectorExpression<eT, Expr2>& table ){
-        std::unordered_set<eT> set( table.begin(), table.end() );
-        return transform( x.begin(), x.end(), [&set](eT y) -> Rboolean {
+        std::unordered_set<eT> set( sugar_begin(table), sugar_end(table) );
+        return transform( sugar_begin(x), sugar_end(x), [&set](eT y) -> Rboolean {
                 return set.count(y) ? TRUE : FALSE ;
         }) ;
     }
diff --git a/inst/include/Rcpp/sugar/operators/arith_Vector_Primitive.h b/inst/include/Rcpp/sugar/operators/arith_Vector_Primitive.h
@@ -10,7 +10,6 @@ operator+(const Rcpp::SugarVectorExpression<eT,Expr>& lhs, eT rhs) -> decltype(
 template <typename eT, typename Expr>
 inline auto
 operator-( const Rcpp::SugarVectorExpression<eT,Expr>& lhs, eT rhs) -> decltype( mapply( std::minus<eT>(), lhs, rhs ) ) {
-    RCPP_DEBUG( "%s - %s (%d)\n", DEMANGLE(Expr), DEMANGLE(eT), rhs )
     return mapply( std::minus<eT>(), lhs, rhs ) ;
 }
 
diff --git a/inst/include/Rcpp/sugar/operators/compound_arith_Vector_Vector.h b/inst/include/Rcpp/sugar/operators/compound_arith_Vector_Vector.h
@@ -0,0 +1,28 @@
+#ifndef Rcpp__sugar__compound_Arith_Vector_Vector_h
+#define Rcpp__sugar__compound_Arith_Vector_Vector_h
+
+template <typename eT, typename Expr1, typename Expr2>
+inline Expr1& operator+=( Expr1& lhs, const Rcpp::SugarVectorExpression<eT, Expr2>& rhs ){
+    lhs = lhs + rhs ;
+    return lhs ;
+}
+
+template <typename eT, typename Expr1, typename Expr2>
+inline Expr1& operator-=( Expr1& lhs, const Rcpp::SugarVectorExpression<eT, Expr2>& rhs ){
+    lhs = lhs - rhs ;
+    return lhs ;
+}
+
+template <typename eT, typename Expr1, typename Expr2>
+inline Expr1& operator*=( Expr1& lhs, const Rcpp::SugarVectorExpression<eT, Expr2>& rhs ){
+    lhs = lhs * rhs ;
+    return lhs ;
+}
+
+template <typename eT, typename Expr1, typename Expr2>
+inline Expr1& operator/=( Expr1& lhs, const Rcpp::SugarVectorExpression<eT, Expr2>& rhs ){
+    lhs = lhs / rhs ;
+    return lhs ;
+}
+
+#endif
diff --git a/inst/include/Rcpp/sugar/operators/compound_arith_Vector_primitive.h b/inst/include/Rcpp/sugar/operators/compound_arith_Vector_primitive.h
@@ -0,0 +1,28 @@
+#ifndef Rcpp__sugar__compound_Arith_Vector_primitive_h
+#define Rcpp__sugar__compound_Arith_Vector_primitive_h
+
+template <int RTYPE, typename Storage, typename eT>
+inline Rcpp::Vector<RTYPE,Storage>& operator+=( Rcpp::Vector<RTYPE,Storage>& lhs, eT rhs ){
+    lhs = lhs + rhs ;
+    return lhs ;    
+}
+
+template <int RTYPE, typename Storage, typename eT>
+inline Rcpp::Vector<RTYPE,Storage>& operator-=( Rcpp::Vector<RTYPE,Storage>& lhs, eT rhs ){
+    lhs = lhs - rhs ;
+    return lhs ;    
+}
+
+template <int RTYPE, typename Storage, typename eT>
+inline Rcpp::Vector<RTYPE,Storage>& operator*=( Rcpp::Vector<RTYPE,Storage>& lhs, eT rhs ){
+    lhs = lhs * rhs ;
+    return lhs ;    
+}
+
+template <int RTYPE, typename Storage, typename eT>
+inline Rcpp::Vector<RTYPE,Storage>& operator/=( Rcpp::Vector<RTYPE,Storage>& lhs, eT rhs ){
+    lhs = lhs / rhs ;
+    return lhs ;    
+}
+
+#endif
diff --git a/inst/include/Rcpp/sugar/operators/operators.h b/inst/include/Rcpp/sugar/operators/operators.h
@@ -10,6 +10,10 @@
 #include <Rcpp/sugar/operators/arith_Vector_Primitive.h>
 #include <Rcpp/sugar/operators/arith_Primitive_Vector.h>
 
+// compound arith vectors
+#include <Rcpp/sugar/operators/compound_arith_Vector_Vector.h>
+#include <Rcpp/sugar/operators/compound_arith_Vector_primitive.h>
+
 // unary operators
 #include <Rcpp/sugar/operators/unary_Vector.h>
 
diff --git a/inst/include/Rcpp/vector/Matrix.h b/inst/include/Rcpp/vector/Matrix.h
@@ -93,6 +93,38 @@ namespace Rcpp{
         inline Row row(int i){ return Row(*this, i) ; }
         inline Row operator()(int i, internal::NamedPlaceHolder){ return row(i); }
         
+        template <typename T>
+        inline Matrix& operator+=( T x ){
+            for( auto& val: *this){ 
+                val += x; 
+            }
+            return *this ;
+        }
+        
+        template <typename T>
+        inline Matrix& operator*=( T x ){
+            for( auto& val: *this){ 
+                val *= x; 
+            }
+            return *this ;
+        }
+        
+        template <typename T>
+        inline Matrix& operator/=( T x ){
+            for( auto& val: *this){ 
+                val /= x; 
+            }
+            return *this ;
+        }
+        
+        template <typename T>
+        inline Matrix& operator-=( T x ){
+            for( auto& val: *this){ 
+                val -= x; 
+            }
+            return *this ;
+        }
+        
     private:
         
         inline R_xlen_t offset(int i, int j) const {
diff --git a/inst/include/Rcpp/vector/SquareMatrix.h b/inst/include/Rcpp/vector/SquareMatrix.h
@@ -0,0 +1,34 @@
+#ifndef Rcpp__vector__SquareMatrix_h
+#define Rcpp__vector__SquareMatrix_h
+
+namespace Rcpp{
+
+    template <int RTYPE, typename Storage>
+    class SquareMatrix : public Matrix<RTYPE, Storage> {
+    public:
+        using Base = Matrix<RTYPE, Storage> ;
+        
+        SquareMatrix( int n ) : Base(n,n){}
+        
+        template <typename U>
+        SquareMatrix( int n, const U& u ) : Base(n,n,u){}
+        
+        SquareMatrix( SEXP x ) : Base(x) {
+            if( Base::nrow() != Base::ncol() )
+                stop( "not a square matrix : %d x %d", Base::nrow(), Base::ncol() ) ;
+        }
+        
+    } ;
+      
+    using SquareComplexMatrix     = SquareMatrix<CPLXSXP> ;  
+    using SquareIntegerMatrix     = SquareMatrix<INTSXP>  ;
+    using SquareLogicalMatrix     = SquareMatrix<LGLSXP>  ;
+    using SquareNumericMatrix     = SquareMatrix<REALSXP> ;
+    using SquareDoubleMatrix      = SquareMatrix<REALSXP> ;
+    using SquareRawMatrix         = SquareMatrix<RAWSXP>  ;
+    using SquareCharacterMatrix   = SquareMatrix<STRSXP> ;
+    using SquareStringMatrix      = SquareMatrix<STRSXP>  ;
+    
+}
+
+#endif
diff --git a/inst/include/Rcpp/vector/dimnames.h b/inst/include/Rcpp/vector/dimnames.h
@@ -0,0 +1,74 @@
+#ifndef Rcpp__Matrix_Dimnames_h
+#define Rcpp__Matrix_Dimnames_h
+
+namespace Rcpp {
+
+    template <typename Data>
+    class RowNamesProxy {
+    public:
+        
+        RowNamesProxy( Data& data_ ) : data(data_){}
+        
+        inline RowNamesProxy& operator=( const CharacterVector& names ){
+            Language call( "rownames<-", data, names ) ;
+            data = call.eval() ;
+            return *this ;    
+        }
+        
+        inline RowNamesProxy& operator=( std::initializer_list<const char*> names ){
+            return this->operator=( CharacterVector(names) ) ;    
+        }
+        
+        inline operator CharacterVector() const {
+            Language call( "rownames", data ) ;
+            return call.eval() ;
+        }
+        
+    private:
+        Data& data ;
+    } ;
+    
+    template <typename Data>
+    class ColNamesProxy {
+    public:
+        
+        ColNamesProxy( Data& data_ ) : data(data_){}
+        
+        inline ColNamesProxy& operator=( const CharacterVector& names ){
+            Language call( "colnames<-", data, names ) ;
+            data = call.eval() ;
+            return *this ;    
+        }
+        
+        inline ColNamesProxy& operator=( std::initializer_list<const char*> names ){
+            return this->operator=( CharacterVector(names) ) ;    
+        }
+        
+        inline operator CharacterVector() const {
+            Language call( "colnames", data ) ;
+            return call.eval() ;
+        }
+        
+    private:
+        Data& data ;
+    } ;
+    
+    
+    template <int RTYPE, typename Storage>
+    inline RowNamesProxy<Matrix<RTYPE, Storage>> rownames( const Matrix<RTYPE, Storage>& m ){
+        return RowNamesProxy<Matrix<RTYPE, Storage>>(const_cast<Matrix<RTYPE,Storage>&>(m)) ;    
+    }
+    
+    template <int RTYPE, typename Storage>
+    inline ColNamesProxy<Matrix<RTYPE, Storage>> colnames( const Matrix<RTYPE, Storage>& m ){
+        return ColNamesProxy<Matrix<RTYPE, Storage>>(const_cast<Matrix<RTYPE,Storage>&>(m)) ;    
+    }
+    
+    template <typename Storage>
+    inline RowNamesProxy<DataFrame_Impl<Storage>> rownames( const DataFrame_Impl<Storage>& df ){
+        return RowNamesProxy<DataFrame_Impl<Storage>>( const_cast<DataFrame_Impl<Storage>&>(df) ) ;    
+    }
+    
+}
+
+#endif
diff --git a/inst/include/Rcpp/vector/impl/LogicalVector.h b/inst/include/Rcpp/vector/impl/LogicalVector.h

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@ operator+(const Rcpp::SugarVectorExpression<eT,Expr>& lhs, eT rhs) -> decltype(`
`10`	`10`	`template <typename eT, typename Expr>`
`11`	`11`	`inline auto`
`12`	`12`	`operator-( const Rcpp::SugarVectorExpression<eT,Expr>& lhs, eT rhs) -> decltype( mapply( std::minus<eT>(), lhs, rhs ) ) {`
`13`		`- RCPP_DEBUG( "%s - %s (%d)\n", DEMANGLE(Expr), DEMANGLE(eT), rhs )`
`14`	`13`	`return mapply( std::minus<eT>(), lhs, rhs ) ;`
`15`	`14`	`}`
`16`	`15`