[Rcpp-commits] r3136 - pkg/RcppEigen/inst/include

[noreply at r-forge.r-project.org]

Author: romain
Date: 2011-07-13 12:24:32 +0200 (Wed, 13 Jul 2011)
New Revision: 3136

Modified:
   pkg/RcppEigen/inst/include/RcppEigenForward.h
   pkg/RcppEigen/inst/include/RcppEigenWrap.h
Log:
comment non generic implementations

Modified: pkg/RcppEigen/inst/include/RcppEigenForward.h
===================================================================
--- pkg/RcppEigen/inst/include/RcppEigenForward.h	2011-07-13 10:13:43 UTC (rev 3135)
+++ pkg/RcppEigen/inst/include/RcppEigenForward.h	2011-07-13 10:24:32 UTC (rev 3136)
@@ -32,18 +32,20 @@
 /* forward declarations */
 namespace Rcpp {
     /* support for wrap */
-    template<typename Derived> SEXP wrap(const Eigen::EigenBase<Derived>&);
+    
+    // [romain] : don't need all this anymore
+    // template<typename Derived> SEXP wrap(const Eigen::EigenBase<Derived>&);
     // template<typename T> SEXP wrap(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>&);
     // template<typename T> SEXP wrap(const Eigen::Matrix<T, Eigen::Dynamic, 1>&);
     // template<typename T> SEXP wrap(const Eigen::Matrix<T, 1, Eigen::Dynamic>&);
-    template<typename T> SEXP wrap(const Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>&);
-    template<typename T> SEXP wrap(const Eigen::Array<T, Eigen::Dynamic, 1>&);
-    template<typename T> SEXP wrap(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> >&);
-    template<typename T> SEXP wrap(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> >&);
-    template<typename T> SEXP wrap(const Eigen::Map<Eigen::Matrix<T, 1, Eigen::Dynamic> >&);
-    template<typename T> SEXP wrap(const Eigen::Map<Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> >&);
-    template<typename T> SEXP wrap(const Eigen::Map<Eigen::Array<T, Eigen::Dynamic, 1> >&);
-    template<typename T> SEXP wrap(const Eigen::SparseMatrix<T>&);
+    // template<typename T> SEXP wrap(const Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>&);
+    // template<typename T> SEXP wrap(const Eigen::Array<T, Eigen::Dynamic, 1>&);
+    // template<typename T> SEXP wrap(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> >&);
+    // template<typename T> SEXP wrap(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> >&);
+    // template<typename T> SEXP wrap(const Eigen::Map<Eigen::Matrix<T, 1, Eigen::Dynamic> >&);
+    // template<typename T> SEXP wrap(const Eigen::Map<Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> >&);
+    // template<typename T> SEXP wrap(const Eigen::Map<Eigen::Array<T, Eigen::Dynamic, 1> >&);
+    // template<typename T> SEXP wrap(const Eigen::SparseMatrix<T>&);
     template<typename T> SEXP wrap(const Eigen::Map<Eigen::SparseMatrix<T> >&);
     
     namespace traits {

Modified: pkg/RcppEigen/inst/include/RcppEigenWrap.h
===================================================================
--- pkg/RcppEigen/inst/include/RcppEigenWrap.h	2011-07-13 10:13:43 UTC (rev 3135)
+++ pkg/RcppEigen/inst/include/RcppEigenWrap.h	2011-07-13 10:24:32 UTC (rev 3136)
@@ -57,6 +57,7 @@
         // so the first thing we need to do is to find out so that we don't evaluate if we don't need to
         template <typename T>
         inline SEXP eigen_wrap( const T& obj ){
+            Rprintf( "eigen wrap\n" ) ;
             return eigen_wrap_is_plain( obj, 
                 typename is_plain<T>::type() 
                 ) ;
@@ -72,16 +73,17 @@
 
     } /* namespace RcppEigen */
 
-    /* wrap */
-	template <typename Derived>
-	SEXP wrap(const Eigen::EigenBase<Derived>& object) {
-//FIXME: Check IsRowMajor and transpose if needed
-		::Rcpp::RObject x = ::Rcpp::wrap(object.data(), object.data() + object.size());
-		if (object.ColsAtCompileTime == 1) return x; // represented as a vector
-		x.attr("dim") = ::Rcpp::Dimension(object.rows(), object.cols());
-	}
-
-    // template <typename T>
+    // /* wrap */
+    // [romain] : no longer necessary
+    // template <typename Derived>
+    // SEXP wrap(const Eigen::EigenBase<Derived>& object) {
+    //     //FIXME: Check IsRowMajor and transpose if needed
+    // 	::Rcpp::RObject x = ::Rcpp::wrap(object.data(), object.data() + object.size());
+    // 	if (object.ColsAtCompileTime == 1) return x; // represented as a vector
+    // 	x.attr("dim") = ::Rcpp::Dimension(object.rows(), object.cols());
+    // }
+    // 
+	// template <typename T>
 	// SEXP wrap(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& data) {
 	// 	return RcppEigen::Eigen_wrap(data, Dimension(data.rows(), data.cols()));
 	// }
@@ -95,43 +97,44 @@
 	// SEXP wrap( const Eigen::Matrix<T, 1, Eigen::Dynamic>& data ){
 	// 	return RcppEigen::Eigen_wrap(data, Dimension(1, data.size()));
     // }
-
-    template <typename T>
-	SEXP wrap(const Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>& data) {
-		return RcppEigen::Eigen_wrap(data, Dimension(data.rows(), data.cols()));
-	}
-    
+    // 
+    // template <typename T>
+	// SEXP wrap(const Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>& data) {
+	// 	return RcppEigen::Eigen_wrap(data, Dimension(data.rows(), data.cols()));
+	// }
+    // 
+	// template <typename T>
+	// SEXP wrap(const Eigen::Array<T, Eigen::Dynamic, 1>& object ){
+	// 	return ::Rcpp::wrap(object.data(), object.data() + object.size());
+    // }
+    // 
+    // template <typename T>
+	// SEXP wrap(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> >& data) {
+	// 	return RcppEigen::Eigen_wrap(data, Dimension(data.rows(), data.cols()));
+	// }
+    // 
+	// template <typename T>
+	// SEXP wrap(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> >& object ){
+	// 	return ::Rcpp::wrap(object.data(), object.data() + object.size());
+    // }
+    // 
+    // template <typename T>
+	// SEXP wrap(const Eigen::Map<Eigen::Matrix<T, 1, Eigen::Dynamic> >& data ){
+	// 	return RcppEigen::Eigen_wrap(data, Dimension(1, data.size()));
+    // }
+    // 
+    // template <typename T>
+	// SEXP wrap(const Eigen::Map<Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> >& data) {
+	// 	return RcppEigen::Eigen_wrap(data, Dimension(data.rows(), data.cols()));
+	// }
+    // 
+	// template <typename T>
+	// SEXP wrap(const Eigen::Map<Eigen::Array<T, Eigen::Dynamic, 1> >& object ){
+	// 	return ::Rcpp::wrap(object.data(), object.data() + object.size());
+    // }
+               
+    // we can probably deal with sparse stuff more generically
 	template <typename T>
-	SEXP wrap(const Eigen::Array<T, Eigen::Dynamic, 1>& object ){
-		return ::Rcpp::wrap(object.data(), object.data() + object.size());
-    }
-
-    template <typename T>
-	SEXP wrap(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> >& data) {
-		return RcppEigen::Eigen_wrap(data, Dimension(data.rows(), data.cols()));
-	}
-    
-	template <typename T>
-	SEXP wrap(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> >& object ){
-		return ::Rcpp::wrap(object.data(), object.data() + object.size());
-    }
-
-    template <typename T>
-	SEXP wrap(const Eigen::Map<Eigen::Matrix<T, 1, Eigen::Dynamic> >& data ){
-		return RcppEigen::Eigen_wrap(data, Dimension(1, data.size()));
-    }
-
-    template <typename T>
-	SEXP wrap(const Eigen::Map<Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> >& data) {
-		return RcppEigen::Eigen_wrap(data, Dimension(data.rows(), data.cols()));
-	}
-    
-	template <typename T>
-	SEXP wrap(const Eigen::Map<Eigen::Array<T, Eigen::Dynamic, 1> >& object ){
-		return ::Rcpp::wrap(object.data(), object.data() + object.size());
-    }
-
-	template <typename T>
     SEXP wrap(const Eigen::Map<Eigen::SparseMatrix<T> >& object ) {
 		int          nnz = object.nonZeros(), p = object.outerSize();
 		Dimension    dim(object.innerSize(), p);