boost ublas: rotate 2d vector

std::copy(v.begin(), v.end(), m.begin1());

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <algorithm>

int main()
{
    boost::numeric::ublas::vector<int> v(10);
    boost::numeric::ublas::matrix<int> m(10,10);  //using v.size() also works
    std::copy(v.begin(), v.end(), m.begin1());
    return 0;
}

#include <RcppCommon.h>

// Flags for C++ compiler

// [[Rcpp::depends(BH)]]
// [[Rcpp::plugins("cpp11")]]

// Third party library includes that provide the template class of ublas
#include <boost/numeric/ublas/matrix_sparse.hpp>
#include <boost/numeric/ublas/matrix.hpp>

// Provide Forward Declarations
namespace Rcpp {

   namespace traits{

   // Setup non-intrusive extension via template specialization for
   // 'ublas' class boost::numeric::ublas

   // Support for wrap
   template <typename T> SEXP wrap(const boost::numeric::ublas::vector<T> & obj);

   // Support for as<T>
   template <typename T> class Exporter< boost::numeric::ublas::vector<T> >;

  }
}

// >> Place <Rcpp.h> AFTER the forward declaration!!!! <<

#include <Rcpp.h>


// >> Place Definitions of Forward Declarations AFTER <Rcpp.h>!!!! <<

// Define template specializations for as<> and wrap

namespace Rcpp {

namespace traits{

// Defined wrap case
template <typename T> SEXP wrap(const boost::numeric::ublas::vector<T> & obj){
  const int RTYPE = Rcpp::traits::r_sexptype_traits<T>::rtype ;

  return Rcpp::Vector< RTYPE >(obj.begin(), obj.end());
};


// Defined as< > case
template<typename T>
class Exporter< boost::numeric::ublas::vector<T> > {
  typedef typename boost::numeric::ublas::vector<T> OUT ;

  // Convert the type to a valid rtype. 
  const static int RTYPE = Rcpp::traits::r_sexptype_traits< T >::rtype ;
  Rcpp::Vector<RTYPE> vec;

public:
  Exporter(SEXP x) : vec(x) {
    if (TYPEOF(x) != RTYPE)
      throw std::invalid_argument("Wrong R type for mapped 1D array");
  }
  OUT get() {

    // Need to figure out a way to perhaps do a pointer pass?
    OUT x(vec.size());

    std::copy(vec.begin(), vec.end(), x.begin()); // have to copy data

    return x;
  }
} ;


}
}

// Here we define a shortcut to the boost ublas class to enable multiple ublas types via a template.
// ublas::vector<T> => ublas::vector<double>, ... , ublas::vector<int>
namespace ublas = ::boost::numeric::ublas;

// [[Rcpp::export]]
void containment_test(Rcpp::NumericVector x1) {

  Rcpp::Rcout << "Converting from Rcpp::NumericVector to ublas::vector<double>" << std::endl;

  ublas::vector<double> x = Rcpp::as< ublas::vector<double> >(x1); // initialize the vector to all zero

  Rcpp::Rcout << "Running output test with ublas::vector<double>" << std::endl;

  for (unsigned i = 0; i < x.size (); ++ i)
    Rcpp::Rcout  << x(i) << std::endl;

  Rcpp::Rcout << "Converting from ublas::vector<double> to Rcpp::NumericVector" << std::endl;

  Rcpp::NumericVector test = Rcpp::wrap(x);

  Rcpp::Rcout << "Running output test with Rcpp::NumericVector" << std::endl;

  for (unsigned i = 0; i < test.size (); ++ i)
    Rcpp::Rcout  << test(i) << std::endl;

}

containment_test(c(1,2,3,4))

Converting from Rcpp::NumericVector to ublas::vector<double>
Running output test with ublas::vector<double>
1
2
3
4
Converting from ublas::vector<double> to Rcpp::NumericVector
Running output test with Rcpp::NumericVector
1
2
3
4

// [[Rcpp::export]]
ublas::vector<double> automagic_ublas_rcpp(ublas::vector<double> x1) {
  return x1;
}

automagic_ublas_rcpp(c(1,2,3.2,1.2))

[1] 1.0 2.0 3.2 1.2

// -------------- Stage 1: Forward Declarations with `RcppCommon.h`

#include <RcppCommon.h>

// Flags for C++ compiler
// [[Rcpp::depends(BH)]]
// [[Rcpp::plugins("cpp11")]]

// Third party library includes that provide the template class of ublas
#include <boost/numeric/ublas/matrix_sparse.hpp>
#include <boost/numeric/ublas/matrix.hpp>


// Here we use ublas_vec to enable multiple ublas types via a template.
// ublas::vector<T> => ublas::vector<double>, ... , ublas::vector<int>
namespace ublas = ::boost::numeric::ublas;


// Provide Forward Declarations
namespace Rcpp {

  namespace traits{

    // Setup non-intrusive extension via template specialization for
    // 'ublas' class boost::numeric::ublas

    // Support for wrap
    template <typename T> SEXP wrap(const boost::numeric::ublas::vector<T> & obj);

    // Support for as<T>
    template <typename T> class Exporter< boost::numeric::ublas::vector<T> >;

  }
}

// -------------- Stage 2: Including Rcpp.h

// >> Place <Rcpp.h> AFTER the forward declaration!!!! <<

#include <Rcpp.h>


// >> Place Definitions of Forward Declarations AFTER <Rcpp.h>!!!! <<


// -------------- Stage 3: Implementation of Declarations

// Define template specializations for as<> and wrap

namespace Rcpp {

  namespace traits{

    // Defined wrap case
    template <typename T> SEXP wrap(const boost::numeric::ublas::vector<T> & obj){
      const int RTYPE = Rcpp::traits::r_sexptype_traits<T>::rtype ;

      return Rcpp::Vector< RTYPE >(obj.begin(), obj.end());
    };


    // Defined as< > case
    template<typename T>
    class Exporter< boost::numeric::ublas::vector<T> > {
      typedef typename boost::numeric::ublas::vector<T> OUT ;

      // Convert the type to a valid rtype. 
      const static int RTYPE = ::Rcpp::traits::r_sexptype_traits< T >::rtype ;
      Rcpp::Vector<RTYPE> vec;

    public:
      Exporter(SEXP x) : vec(x) {
        if (TYPEOF(x) != RTYPE)
          throw std::invalid_argument("Wrong R type for mapped 1D array");
      }
      OUT get() {

        // Need to figure out a way to perhaps do a pointer pass?
        OUT x(vec.size());

        std::copy(vec.begin(), vec.end(), x.begin()); // have to copy data

        return x;
      }
    } ;


  }
}

// -------------- Stage 4: Tests

// [[Rcpp::export]]
ublas::vector<double> automagic_ublas_rcpp(ublas::vector<double> x1) {
  return x1;
}


// [[Rcpp::export]]
void containment_test(Rcpp::NumericVector x1) {

  Rcpp::Rcout << "Converting from Rcpp::NumericVector to ublas::vector<double>" << std::endl;

  ublas::vector<double> x = Rcpp::as< ublas::vector<double> >(x1); // initialize the vector to all zero

  Rcpp::Rcout << "Running output test with ublas::vector<double>" << std::endl;

  for (unsigned i = 0; i < x.size (); ++ i)
    Rcpp::Rcout  << x(i) << std::endl;

  Rcpp::Rcout << "Converting from ublas::vector<double> to Rcpp::NumericVector" << std::endl;

  Rcpp::NumericVector test = Rcpp::wrap(x);

  Rcpp::Rcout << "Running output test with Rcpp::NumericVector" << std::endl;

  for (unsigned i = 0; i < test.size (); ++ i)
    Rcpp::Rcout  << test(i) << std::endl;

}