revert reader/writer classes

jjallaire · jjallaire · commit 73fd918486b5 · 2014-07-13T08:22:09.000-04:00
diff --git a/inst/examples/parallel-inner-product.cpp b/inst/examples/parallel-inner-product.cpp
@@ -18,25 +18,24 @@ double innerProduct(NumericVector x, NumericVector y) {
 
 // [[Rcpp::depends(RcppParallel)]]
 #include <RcppParallel.h>
-using namespace RcppParallel;
 
-struct InnerProduct : public Worker
+struct InnerProduct : public RcppParallel::Worker
 {   
    // source vectors
-   NumericVectorReader x;
-   NumericVectorReader y;
+   double * x;
+   double * y;
    
    // product that I have accumulated
    double product;
    
    // constructors
-   InnerProduct(NumericVector x, NumericVector y) : x(x), y(y), product(0) {}
-   InnerProduct(InnerProduct& innerProduct, Split) 
+   InnerProduct(double * const x, double * const y) : x(x), y(y), product(0) {}
+   InnerProduct(InnerProduct& innerProduct, RcppParallel::Split) 
       : x(innerProduct.x), y(innerProduct.y), product(0) {}
    
    // process just the elements of the range I've been asked to
    void operator()(std::size_t begin, std::size_t end) {
-      product += std::inner_product(x[begin], x[end], y[begin], 0.0);
+      product += std::inner_product(x + begin, x + end, y + begin, 0.0);
    }
    
    // join my value with that of another InnerProduct
@@ -49,10 +48,10 @@ struct InnerProduct : public Worker
 double parallelInnerProduct(NumericVector x, NumericVector y) {
    
    // declare the InnerProduct instance that takes a pointer to the vector data
-   InnerProduct innerProduct(x, y);
+   InnerProduct innerProduct(x.begin(), y.begin());
    
    // call paralleReduce to start the work
-   parallelReduce(0, x.length(), innerProduct);
+   RcppParallel::parallelReduce(0, x.length(), innerProduct);
    
    // return the computed product
    return innerProduct.product;
diff --git a/inst/examples/parallel-matrix-transform.cpp b/inst/examples/parallel-matrix-transform.cpp
@@ -28,23 +28,23 @@ NumericMatrix matrixSqrt(NumericMatrix orig) {
 
 // [[Rcpp::depends(RcppParallel)]]
 #include <RcppParallel.h>
-using namespace RcppParallel;
 
-struct SquareRoot : public Worker
+struct SquareRoot : public RcppParallel::Worker
 {
    // source matrix
-   NumericMatrixReader input;
+   double* input;
    
    // destination matrix
-   NumericMatrixWriter output;
+   double* output;
    
    // initialize with source and destination
-   SquareRoot(NumericMatrix input, NumericMatrix output) 
+   SquareRoot() : input(NULL), output(NULL) {}
+   SquareRoot(double* input, double* output) 
       : input(input), output(output) {}
    
    // take the square root of the range of elements requested
    void operator()(std::size_t begin, std::size_t end) {
-      std::transform(input[begin], input[end], output[begin], ::sqrt);
+      std::transform(input + begin, input + end, output + begin, ::sqrt);
    }
 };
 
@@ -55,10 +55,10 @@ NumericMatrix parallelMatrixSqrt(NumericMatrix x) {
   NumericMatrix output(x.nrow(), x.ncol());
   
   // SquareRoot instance that takes a pointer to the input & output data
-  SquareRoot squareRoot(x, output);
+  SquareRoot squareRoot(x.begin(), output.begin());
   
   // call parallelFor to do the work
-  parallelFor(0, x.length(), squareRoot);
+  RcppParallel::parallelFor(0, x.length(), squareRoot);
   
   // return the output matrix
   return output;
diff --git a/inst/examples/parallel-vector-sum.cpp b/inst/examples/parallel-vector-sum.cpp
@@ -19,23 +19,22 @@ double vectorSum(NumericVector x) {
 
 // [[Rcpp::depends(RcppParallel)]]
 #include <RcppParallel.h>
-using namespace RcppParallel;
 
-struct Sum : public Worker
+struct Sum : public RcppParallel::Worker
 {   
    // source vector
-   NumericVectorReader input;
+   double * input;
    
    // value that I have accumulated
    double value;
    
    // constructors
-   Sum(NumericVector x) : input(x), value(0) {}
-   Sum(Sum& sum, Split) : input(sum.input), value(0) {}
+   Sum(double* input) : input(input), value(0) {}
+   Sum(Sum& sum, RcppParallel::Split) : input(sum.input), value(0) {}
    
    // accumulate just the element of the range I've been asked to
    void operator()(std::size_t begin, std::size_t end) {
-      value += std::accumulate(input[begin], input[end], 0.0);
+      value += std::accumulate(input + begin, input + end, 0.0);
    }
      
    // join my value with that of another Sum
@@ -48,10 +47,10 @@ struct Sum : public Worker
 double parallelVectorSum(NumericVector x) {
    
    // declare the SumBody instance that takes a pointer to the vector data
-   Sum sum(x);
+   Sum sum(x.begin());
    
    // call parallel_reduce to start the work
-   parallelReduce(0, x.length(), sum);
+   RcppParallel::parallelReduce(0, x.length(), sum);
    
    // return the computed sum
    return sum.value;
diff --git a/inst/include/RcppParallel.h b/inst/include/RcppParallel.h
@@ -15,9 +15,6 @@
 #endif
 #endif
 
-#include "RcppParallel/Vector.h"
-#include "RcppParallel/Matrix.h"
-
 namespace RcppParallel {
 
 inline void parallelFor(std::size_t begin, std::size_t end, 
diff --git a/inst/include/RcppParallel/Matrix.h b/inst/include/RcppParallel/Matrix.h
diff --git a/inst/include/RcppParallel/Vector.h b/inst/include/RcppParallel/Vector.h
