Merge pull request #18 from dcdillon/feature/matrices

First pass at matrix stuff!

Author: dcdillon

.travis.yml

@@ -12,7 +12,8 @@ before_install:
   - ./run.sh bootstrap
 
 install:
-  - ./run.sh install_aptget r-cran-rcpp r-cran-runit r-cran-knitr r-cran-rmarkdown
+  - ./run.sh install_r Rcpp
+  - ./run.sh install_aptget r-cran-runit r-cran-knitr r-cran-rmarkdown
 
 script:
   - ./run.sh run_tests

DESCRIPTION

@@ -12,7 +12,7 @@ Description: Creates an easy way to use expression templates with R
 License: GPL (>= 2)
 LazyData: TRUE
 Imports:
-    Rcpp (>= 0.12.5)
+    Rcpp (>= 0.12.8)
 Suggests:
     RUnit,
     knitr,

R/plugin.R

@@ -1,2 +1,18 @@
-inlineCxxPlugin <- Rcpp:::Rcpp.plugin.maker(libs =
-                       if (Sys.info()[['sysname']] != "SunOS") "-Wl,-S" else "")
+.getLibs <- function() {
+    linker_pattern <- "gcc|clang|g\\+\\+"
+
+    shlib_ld <- system("R CMD config SHLIB_LD", intern=TRUE)
+    shlib_cxxld <- system("R CMD config SHLIB_CXXLD", intern=TRUE)
+
+    shlib_ld_results <- system(paste0(shlib_ld, " --version"), intern=TRUE)
+    shlib_cxxld_results <- system(paste0(shlib_cxxld, " --version"), intern=TRUE)
+
+    shlib_ld_good <- any(grepl(linker_pattern, shlib_ld_results))
+    shlib_cxxld_good <- any(grepl(linker_pattern, shlib_cxxld_results))
+
+    libs <- if (shlib_ld_good && shlib_cxxld_good) "-Wl,-S" else ""
+
+    libs
+}
+
+inlineCxxPlugin <- Rcpp:::Rcpp.plugin.maker(libs = .getLibs())

README.md

@@ -6,7 +6,7 @@
 
 The goal is to provide full featured interoperability between any iterator based structures and `R` to reduce development time and simplify code.
 
-`RcppHoney` is in alpha state (so the API is still subject to change, but is way more stable than it was a week ago).
+`RcppHoney` is now in a beta state so the API should no longer be changing.
 
 ### Example
 
@@ -60,7 +60,7 @@ namespace RcppHoney {
 namespace functors {
 
 template< typename Iterator, bool NA >
-struct my_unary_functor {
+struct my_unary_functor : public unary_result_dims {
     typedef typename std::iterator_traits< Iterator >::value_type rhs_value_type;
     // since we're just adding a double to the input value the return type should be
     // the widest numeric type of rhs and double
@@ -79,7 +79,7 @@ struct my_unary_functor {
 };
 
 template< typename LhsIterator, typename RhsIterator, bool NA = true >
-struct my_binary_functor {
+struct my_binary_functor : binary_result_dims {
     typedef typename std::iterator_traits< LhsIterator >::value_type lhs_value_type;
     typedef typename std::iterator_traits< RhsIterator >::value_type rhs_value_type;
 
@@ -148,16 +148,22 @@ Rcpp::NumericVector rcpphoney_example() {
 
 ### Installation
 
-RcppHoney is still in alpha state, and it is recommended you install from source
-as changes will be frequent.
+RcppHoney is now a in beta state!
 
-RcppHoney is also available via the [CRAN](http://cran.r-project.org) network,
+RcppHoney is available via the [CRAN](http://cran.r-project.org) network,
 and can be installed from within R via 
 
 ```R
 install.packages("RcppHoney")
 ```
 
+RcppHoney can also be installed from the github sources by running
+
+```
+git clone [email protected]:dcdillon/RcppHoney
+R CMD INSTALL RcppHoney
+```
+
 ### Authors
 
 Daniel C. Dillon

configure

@@ -1,9 +1 @@
-MYOS=`uname -s`
-
-echo $MYOS
-
-if [ "$(echo "$MYOS" | cut -c1-5)" = "SunOS" ]; then
-	cp src/platform/Makevars.solaris src/Makevars
-else
-	cp src/platform/Makevars.gcc src/Makevars
-fi
+./inst/tools/stripper

inst/include/RcppHoney.hpp

@@ -19,7 +19,6 @@
 
 #include "RcppHoneyForward.hpp"
 #include <Rcpp.h>
-#include "RcppHoney/wrap.hpp"
 #include "RcppHoney/operators.hpp"
 #include "RcppHoney/functions.hpp"
 #include "RcppHoney/storage.hpp"

inst/include/RcppHoney/binary_operator.hpp

@@ -17,7 +17,6 @@
 
 #pragma once
 
-#include <Rcpp.h>
 #include <iterator>
 #include <algorithm>
 #include <cstddef>
@@ -107,24 +106,23 @@ class binary_operator : public operand< binary_operator< LhsIterator, RhsIterato
     LhsIterator m_lhsEnd;
     RhsIterator m_rhsBegin;
     RhsIterator m_rhsEnd;
-    std::size_t m_length;
+    dims_t m_dims;
     Op m_operator;
 
 public:
-    binary_operator(LhsIterator lhsBegin, LhsIterator lhsEnd, int64_t lhsSize,
-        RhsIterator rhsBegin, RhsIterator rhsEnd, int64_t rhsSize, const Op &op) :
+    binary_operator(LhsIterator lhsBegin, LhsIterator lhsEnd, dims_t lhsDims,
+        RhsIterator rhsBegin, RhsIterator rhsEnd, dims_t rhsDims, const Op &op) :
             m_lhsBegin(lhsBegin), m_lhsEnd(lhsEnd), m_rhsBegin(rhsBegin),
-                m_rhsEnd(rhsEnd), m_length(std::max(lhsSize, rhsSize)),
-                    m_operator(op) {
+                m_rhsEnd(rhsEnd), m_operator(op) {
 
-        if (lhsSize != rhsSize && lhsSize != -1 && rhsSize != -1) {
-            std::cout << lhsSize << ", " << rhsSize << std::endl;
-            throw bounds_exception();
-        }
+        m_dims = m_operator.result_dims(lhsDims, rhsDims);
     }
 
-    int64_t length() const {return m_length;}
-    int64_t size() const {return m_length;}
+    dims_t dims() const {return m_dims;}
+    int64_t size() const {
+        return (m_dims.second != 0) ? m_dims.first * m_dims.second
+            : m_dims.first;
+    }
     const_iterator begin() const {return const_iterator(m_lhsBegin, m_rhsBegin, &m_operator);}
     const_iterator end() const {return const_iterator(m_lhsEnd, m_rhsEnd, &m_operator);}
 };
@@ -136,8 +134,8 @@ struct make_binary_operator
     binary_operator< typename LHS::const_iterator, typename RHS::const_iterator, Op, NA > operator()(const LHS &lhs, const RHS &rhs, const Op &op) {
 
         return binary_operator< typename LHS::const_iterator, typename RHS::const_iterator, Op, NA >(
-                lhs.begin(), lhs.end(), hooks::extract_size(lhs),
-                rhs.begin(), rhs.end(), hooks::extract_size(rhs),
+                lhs.begin(), lhs.end(), hooks::extract_dims(lhs),
+                rhs.begin(), rhs.end(), hooks::extract_dims(rhs),
                 op);
     }
 };

inst/include/RcppHoney/default_hooks.hpp

@@ -51,5 +51,43 @@ RcppHoney::traits::true_type needs_scalar_operators(const Rcpp::VectorBase< RTYP
 template< int RTYPE, bool NA, typename T >
 RcppHoney::traits::int_constant< 2 > family(const Rcpp::VectorBase< RTYPE, NA, T > &val);
 
+
+
+
+
+
+
+// hooks for Rcpp::VectorBase
+template< int RTYPE, template< class > class StoragePolicy >
+RcppHoney::traits::true_type is_hooked(const Rcpp::Matrix< RTYPE, StoragePolicy > &val);
+
+// return the appropriate NA value
+template< int RTYPE, template< class > class StoragePolicy >
+RcppHoney::traits::true_type has_na(const Rcpp::Matrix< RTYPE, StoragePolicy > &val);
+
+// assert that we need to create basic operators
+template< int RTYPE, template< class > class StoragePolicy >
+RcppHoney::traits::true_type needs_basic_operators(const Rcpp::Matrix< RTYPE, StoragePolicy > &val);
+
+// assert that we need to create type + scalar operators
+template< int RTYPE, template< class > class StoragePolicy >
+RcppHoney::traits::true_type needs_scalar_operators(const Rcpp::Matrix< RTYPE, StoragePolicy > &val);
+
+// call this family 3
+template< int RTYPE, template< class > class StoragePolicy >
+RcppHoney::traits::int_constant< 3 > family(const Rcpp::Matrix< RTYPE, StoragePolicy > &val);
+
+template< int RTYPE, template< class > class StoragePolicy >
+dims_t extract_dims(
+    const Rcpp::Matrix< RTYPE, StoragePolicy > &obj)
+{
+    return dims_t(obj.nrow(), obj.ncol());
+}
+
+template< typename T, typename T_ITER, typename T_RESULT >
+dims_t extract_dims(const operand< T, T_ITER, T_RESULT > &obj) {
+    return obj.dims();
+}
+
 } // namespace hooks
 } // namespace RcppHoney

inst/include/RcppHoney/functions.hpp

@@ -17,7 +17,6 @@
 
 #pragma once
 
-#include <Rcpp.h>
 #include "operand.hpp"
 #include "scalar_operator.hpp"
 #include "unary_operator.hpp"
@@ -264,10 +263,15 @@ RCPP_HONEY_GENERATE_BINARY_FUNCTION(signif, signif)
 template< typename T, typename T_ITER, typename T_RESULT >
 unary_operator< T_ITER, functors::diff< T_ITER, T::NA >, T::NA >
 diff(const operand< T, T_ITER, T_RESULT > &rhs) {
+
+    if (rhs.dims().second != 0) {
+        throw bounds_exception();
+    }
+
     T_ITER begin = rhs.begin();
     ++begin;
     return unary_operator< T_ITER, functors::diff< T_ITER, T::NA >, T::NA >(
-        begin, rhs.end(), hooks::extract_size(rhs) - 1, functors::diff< T_ITER, T::NA >());
+        begin, rhs.end(), rhs.dims(), functors::diff< T_ITER, T::NA >());
 }
 
 template< typename T >
@@ -280,14 +284,20 @@ typename traits::enable_if<
     >
 >::type
 diff(const T &rhs) {
+    dims_t dims = hooks::extract_dims(rhs);
+
+    if (dims.second != 0) {
+        throw bounds_exception();
+    }
+
     typename hook< T >::const_iterator begin = rhs.begin();
     ++begin;
 
     return unary_operator<
         typename hook< T >::const_iterator,
         functors::diff< typename hook< T >::const_iterator, hook< T >::NA >,
         hook< T >::NA
-    >(begin, rhs.end(), hooks::extract_size(rhs) - 1,
+    >(begin, rhs.end(), dims,
         functors::diff< typename hook< T >::const_iterator, hook< T >::NA >());
 }