[Rcpp-commits] r2810 - in pkg/Rcpp/inst: include/Rcpp/sugar/operators unitTests

noreply at r-forge.r-project.org noreply at r-forge.r-project.org
Wed Dec 22 12:35:25 CET 2010


Author: romain
Date: 2010-12-22 12:35:25 +0100 (Wed, 22 Dec 2010)
New Revision: 2810

Added:
   pkg/Rcpp/inst/unitTests/runit.support.R
Modified:
   pkg/Rcpp/inst/include/Rcpp/sugar/operators/plus.h
Log:
better performance for +

Modified: pkg/Rcpp/inst/include/Rcpp/sugar/operators/plus.h
===================================================================
--- pkg/Rcpp/inst/include/Rcpp/sugar/operators/plus.h	2010-12-20 21:34:00 UTC (rev 2809)
+++ pkg/Rcpp/inst/include/Rcpp/sugar/operators/plus.h	2010-12-22 11:35:25 UTC (rev 2810)
@@ -50,7 +50,37 @@
 	private:
 		const LHS_EXT& lhs ;
 		const RHS_EXT& rhs ;
-	} ;	
+	} ;
+	// specialization of the above for REALSXP because : 
+	// NA_REAL + NA_REAL = NA_REAL
+	// NA_REAL + x = NA_REAL
+	// x + NA_REAL = NA_REAL
+	template <bool LHS_NA, typename LHS_T, bool RHS_NA, typename RHS_T >
+	class Plus_Vector_Vector<REALSXP,LHS_NA,LHS_T,RHS_NA,RHS_T> : 
+	    public Rcpp::VectorBase<REALSXP, true , Plus_Vector_Vector<REALSXP,LHS_NA,LHS_T,RHS_NA,RHS_T> > {
+	public:
+		typedef typename Rcpp::VectorBase<REALSXP,LHS_NA,LHS_T> LHS_TYPE ;
+		typedef typename Rcpp::VectorBase<REALSXP,RHS_NA,RHS_T> RHS_TYPE ;
+		
+		typedef typename Rcpp::traits::Extractor<REALSXP, LHS_NA, LHS_T>::type LHS_EXT ;
+		typedef typename Rcpp::traits::Extractor<REALSXP, RHS_NA, RHS_T>::type RHS_EXT ;
+		
+		Plus_Vector_Vector( const LHS_TYPE& lhs_, const RHS_TYPE& rhs_ ) : 
+			lhs(lhs_.get_ref()), rhs(rhs_.get_ref()) {}
+		
+		inline double operator[]( int i ) const {
+			return lhs[i] + rhs[i] ;
+		}
+		
+		inline int size() const { return lhs.size() ; }
+		
+	private:
+		const LHS_EXT& lhs ;
+		const RHS_EXT& rhs ;
+	} ;
+
+
+
 	
 	// specialization LHS_NA = false
 	template <int RTYPE, typename LHS_T, bool RHS_NA, typename RHS_T >
@@ -78,7 +108,33 @@
 		const LHS_EXT& lhs ;
 		const RHS_EXT& rhs ;
 	} ;	
+	// LHS_NA = false & RTYPE = REALSXP
+	template <typename LHS_T, bool RHS_NA, typename RHS_T >
+	class Plus_Vector_Vector<REALSXP,false,LHS_T,RHS_NA,RHS_T> : 
+	    public Rcpp::VectorBase<REALSXP,true, Plus_Vector_Vector<REALSXP,false,LHS_T,RHS_NA,RHS_T> > {
+	public:
+		typedef typename Rcpp::VectorBase<REALSXP,false,LHS_T> LHS_TYPE ;
+		typedef typename Rcpp::VectorBase<REALSXP,RHS_NA,RHS_T> RHS_TYPE ;
+		
+		typedef typename Rcpp::traits::Extractor<REALSXP, false, LHS_T>::type LHS_EXT ;
+		typedef typename Rcpp::traits::Extractor<REALSXP, RHS_NA, RHS_T>::type RHS_EXT ;
+		
+		Plus_Vector_Vector( const LHS_TYPE& lhs_, const RHS_TYPE& rhs_ ) : 
+			lhs(lhs_.get_ref()), rhs(rhs_.get_ref()){}
+		
+		inline double operator[]( int i ) const {
+			return lhs[i] + rhs[i] ;
+		}
+		
+		inline int size() const { return lhs.size() ; }
+		
+	private:
+		const LHS_EXT& lhs ;
+		const RHS_EXT& rhs ;
+	} ;	
 
+	
+	
 	// specialization for RHS_NA = false 
 	template <int RTYPE, bool LHS_NA, typename LHS_T, typename RHS_T >
 	class Plus_Vector_Vector<RTYPE,LHS_NA,LHS_T,false,RHS_T> : public Rcpp::VectorBase<RTYPE, true , Plus_Vector_Vector<RTYPE,LHS_NA,LHS_T,false,RHS_T> > {
@@ -104,8 +160,34 @@
 	private:
 		const LHS_EXT& lhs ;
 		const RHS_EXT& rhs ;
+	} ;
+    // RHS_NA = false, RTYPE = REALSXP	
+	template <bool LHS_NA, typename LHS_T, typename RHS_T >
+	class Plus_Vector_Vector<REALSXP,LHS_NA,LHS_T,false,RHS_T> : 
+	    public Rcpp::VectorBase<REALSXP, true , Plus_Vector_Vector<REALSXP,LHS_NA,LHS_T,false,RHS_T> > {
+	public:
+		typedef typename Rcpp::VectorBase<REALSXP,LHS_NA,LHS_T> LHS_TYPE ;
+		typedef typename Rcpp::VectorBase<REALSXP,false,RHS_T> RHS_TYPE ;
+		
+		typedef typename Rcpp::traits::Extractor<REALSXP, LHS_NA, LHS_T>::type LHS_EXT ;
+		typedef typename Rcpp::traits::Extractor<REALSXP, false, RHS_T>::type RHS_EXT ;
+		
+		Plus_Vector_Vector( const LHS_TYPE& lhs_, const RHS_TYPE& rhs_ ) : 
+			lhs(lhs_.get_ref()), rhs(rhs_.get_ref()){}
+		
+		inline double operator[]( int i ) const {
+			return lhs[i] + rhs[i] ;
+		}
+		
+		inline int size() const { return lhs.size() ; }
+		
+	private:
+		const LHS_EXT& lhs ;
+		const RHS_EXT& rhs ;
 	} ;	
 
+	
+	
 
 	// specialization for RHS_NA = false  and LHS_NA = false 
 	template <int RTYPE, typename LHS_T, typename RHS_T >
@@ -131,11 +213,40 @@
 		const LHS_EXT& lhs ;
 		const RHS_EXT& rhs ;
 	} ;	
+	// specialization for RHS_NA = false  and LHS_NA = false, RTYPE = REALSXP 
+	template <typename LHS_T, typename RHS_T >
+	class Plus_Vector_Vector<REALSXP,false,LHS_T,false,RHS_T> : 
+	    public Rcpp::VectorBase<REALSXP, false , Plus_Vector_Vector<REALSXP,false,LHS_T,false,RHS_T> > {
+	public:
+		typedef typename Rcpp::VectorBase<REALSXP,false,LHS_T> LHS_TYPE ;
+		typedef typename Rcpp::VectorBase<REALSXP,false,RHS_T> RHS_TYPE ;
+		
+		typedef typename Rcpp::traits::Extractor<REALSXP, false, LHS_T>::type LHS_EXT ;
+		typedef typename Rcpp::traits::Extractor<REALSXP, false, RHS_T>::type RHS_EXT ;
+		                                                     
+		Plus_Vector_Vector( const LHS_TYPE& lhs_, const RHS_TYPE& rhs_ ) : 
+			lhs(lhs_.get_ref()), rhs(rhs_.get_ref()){}
+		
+		inline double operator[]( int i ) const {
+			return lhs[i] + rhs[i]  ;
+		}
+		
+		inline int size() const { return lhs.size() ; }
+		
+	private:
+		const LHS_EXT& lhs ;
+		const RHS_EXT& rhs ;
+	} ;	
 	
 	
 	
+	
+	
+	
+	
 	template <int RTYPE, bool NA, typename T>
-	class Plus_Vector_Primitive : public Rcpp::VectorBase<RTYPE,true, Plus_Vector_Primitive<RTYPE,NA,T> > {
+	class Plus_Vector_Primitive : 
+	    public Rcpp::VectorBase<RTYPE,true, Plus_Vector_Primitive<RTYPE,NA,T> > {
 	public:
 		typedef typename Rcpp::VectorBase<RTYPE,NA,T> VEC_TYPE ;
 		typedef typename traits::storage_type<RTYPE>::type STORAGE ;
@@ -160,7 +271,30 @@
 		bool rhs_na ;
 		
 	} ;
+	// RTYPE = REALSXP
+	template <bool NA, typename T>
+	class Plus_Vector_Primitive<REALSXP,NA,T> : 
+	    public Rcpp::VectorBase<REALSXP,true, Plus_Vector_Primitive<REALSXP,NA,T> > {
+	public:
+		typedef typename Rcpp::VectorBase<REALSXP,NA,T> VEC_TYPE ;
+		typedef typename Rcpp::traits::Extractor< REALSXP, NA, T>::type EXT ;
+		
+		Plus_Vector_Primitive( const VEC_TYPE& lhs_, double rhs_ ) : 
+			lhs(lhs_.get_ref()), rhs(rhs_)
+			{}
+		
+		inline double operator[]( int i ) const {
+			return rhs + lhs[i] ; 
+		}
+		
+		inline int size() const { return lhs.size() ; }
+		
+	private:
+		const EXT& lhs ;
+		double rhs ;
+	} ;
 	
+
 	
 	template <int RTYPE, typename T>
 	class Plus_Vector_Primitive<RTYPE,false,T> : public Rcpp::VectorBase<RTYPE,false, Plus_Vector_Primitive<RTYPE,false,T> > {
@@ -183,7 +317,28 @@
 		const EXT& lhs ;
 		STORAGE rhs ;
 		bool rhs_na ;
+	} ;
+	// RTYPE = REALSXP
+	template <typename T>
+	class Plus_Vector_Primitive<REALSXP,false,T> : 
+	    public Rcpp::VectorBase<REALSXP,false, Plus_Vector_Primitive<REALSXP,false,T> > {
+	public:
+		typedef typename Rcpp::VectorBase<REALSXP,false,T> VEC_TYPE ;
 		
+		typedef typename Rcpp::traits::Extractor< REALSXP, false, T>::type EXT ;
+		
+		Plus_Vector_Primitive( const VEC_TYPE& lhs_, double rhs_ ) : 
+			lhs(lhs_.get_ref()), rhs(rhs_) {}
+		
+		inline double operator[]( int i ) const {
+			return rhs + lhs[i] ;
+		}
+		
+		inline int size() const { return lhs.size() ; }
+		
+	private:
+		const EXT& lhs ;
+		double rhs ;
 	} ;
 	
 
@@ -192,7 +347,6 @@
 	
 	
 	// Vector * nona(primitive)
-	
 	template <int RTYPE, bool NA, typename T>
 	class Plus_Vector_Primitive_nona : public Rcpp::VectorBase<RTYPE,true, Plus_Vector_Primitive_nona<RTYPE,NA,T> > {
 	public:
@@ -216,6 +370,29 @@
 		STORAGE rhs ;
 		
 	} ;
+	template <bool NA, typename T>
+	class Plus_Vector_Primitive_nona<REALSXP,NA,T> : 
+	    public Rcpp::VectorBase<REALSXP,true, Plus_Vector_Primitive_nona<REALSXP,NA,T> > {
+	public:
+		typedef typename Rcpp::VectorBase<REALSXP,NA,T> VEC_TYPE ;
+		typedef typename Rcpp::traits::Extractor<REALSXP, NA, T>::type EXT ;
+		   
+		Plus_Vector_Primitive_nona( const VEC_TYPE& lhs_, double rhs_ ) : 
+			lhs(lhs_.get_ref()), rhs(rhs_)
+			{}
+		
+		inline double operator[]( int i ) const {
+			return rhs + lhs[i] ;
+		}
+		
+		inline int size() const { return lhs.size() ; }
+		
+	private:
+		const EXT& lhs ;
+		double rhs ;
+		
+	} ;
+	
 
 	
 	template <int RTYPE, typename T>
@@ -240,6 +417,28 @@
 		STORAGE rhs ;
 		
 	} ;
+	// RTYPE = REALSXP
+	template <typename T>
+	class Plus_Vector_Primitive_nona<REALSXP,false,T> : 
+	    public Rcpp::VectorBase<REALSXP,false, Plus_Vector_Primitive_nona<REALSXP,false,T> > {
+	public:
+		typedef typename Rcpp::VectorBase<REALSXP,false,T> VEC_TYPE ;
+		typedef typename Rcpp::traits::Extractor< REALSXP, false, T>::type EXT ;
+		
+		Plus_Vector_Primitive_nona( const VEC_TYPE& lhs_, double rhs_ ) : 
+			lhs(lhs_.get_ref()), rhs(rhs_) {}
+		
+		inline double operator[]( int i ) const {
+			return rhs + lhs[i] ;
+		}
+		
+		inline int size() const { return lhs.size() ; }
+		
+	private:
+		const EXT& lhs ;
+		double rhs ;
+		
+	} ;
 	
 }
 }

Added: pkg/Rcpp/inst/unitTests/runit.support.R
===================================================================
--- pkg/Rcpp/inst/unitTests/runit.support.R	                        (rev 0)
+++ pkg/Rcpp/inst/unitTests/runit.support.R	2010-12-22 11:35:25 UTC (rev 2810)
@@ -0,0 +1,47 @@
+#!/usr/bin/r -t
+#
+# Copyright (C) 2010	Dirk Eddelbuettel and Romain Francois
+#
+# This file is part of Rcpp.
+#
+# Rcpp is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# Rcpp is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rcpp.  If not, see <http://www.gnu.org/licenses/>.
+
+definitions <- function() {
+    list("plus_REALSXP"=list(
+              signature(),
+              '
+              return List::create( 
+                NA_REAL + NA_REAL, 
+                NA_REAL + 1.0,
+                1.0 + NA_REAL 
+                ); 
+              ')
+    )
+}
+.setUp <- function() {
+    tests <- ".rcpp.support"
+    if( ! exists( tests, globalenv() )) {
+        fun <- Rcpp:::compile_unit_tests(definitions())
+        assign( tests, fun, globalenv() )
+    }
+}
+
+test.plus.REALSXP <- function(){
+    fun <- .rcpp.as$plus_REALSXP
+    checkEquals( 
+        fun(), 
+        list(NA_real_,NA_real_,NA_real_) , 
+        msg = " REALSXP + REALSXP" )
+}
+



More information about the Rcpp-commits mailing list