Dear Romain, and other Rcpp-devel members. I need some help. I've looked into the code Romain posted a few weeks ago, and I see that I can't change the example from working on double to working on String. I keep running into the error of: no matching function for call to 'range_wrap_dispatch__impl(__gnu_cxx::__normal_iterator<const:Rcpp::String*,str::vector<Rcpp::String>
& __gnu_cxx__normal_iterator<const Rcpp::String*,std::vector<Rcpp::String> & Rcpp::trait::r_type_trait<<Rcpp::String>::r_category)
Any ideas what I might be doing wrong?
(thanks up front)
Here is the code I used in sourceCpp:
////////////////////////////////////
bool is_list(RObject x){
return TYPEOF(x) == VECSXP ;
}
bool is_string(RObject x){
return TYPEOF(x) == STRSXP && Rf_length(x) == 1 ;
}
bool is_logical(RObject x){
return TYPEOF(x) == LGLSXP && Rf_length(x) == 1 ;
}
bool is_leaf(RObject x){
if( TYPEOF(x) != REALSXP ) return false ;
if( !is_logical( x.attr("leaf") ) ) return false ;
bool leaf = x.attr( "leaf" ) ;
return leaf; // either TRUE or FALSE. But often, if it exists - it is
TRUE.
}
String get_label(RObject x){
String label = x.attr( "label" ) ;
return label; // either TRUE or FALSE. But often, if it exists - it is
TRUE.
}
//void process( List data, std::vector<double>& results ){
//void process( List data, CharacterVector& results ){
//void process( List data, std::vector<std::string>& results){
void process( List data, std::vector<String>& results ){
for( int i=0; i<data.size(); i++){
if( is_list( data[i] ) ){
// recurse
process( data[i], results ) ;
} else if( is_leaf( data[i] ) ){
// we want to collect them. we can use the NumericVector class
// wince we know this is a numeric vector.
// (it is tested in is_leaf)
// NumericVector y = data[i] ;
// String x_label = y.attr("label");
String x_label = get_label(data[i]);
results.push_back(x_label);
// loop through the values and add them to the results vector
// for( int j=0; j<x.size(); j++){
// results.push_back( x[j] ) ;
// }
} // else do nothing
}
}
// [[Rcpp::export]]
CharacterVector extract_fun(List x){
// std::vector<double> results ;
std::vector<String> results ;
process(x, results) ;
return wrap(results) ;
}
/*** R
x <- list(a = 1, b = 2, c = list(ca = 3, cb = 4, 5), 6)
attr(x[[1]], "leaf") = TRUE
attr(x[[1]], "label") = "leaf 1"
attr(x[[3]][[1]], "leaf") = TRUE
attr(x[[2]], "leaf") = TRUE
attr(x[[2]], "label") = "leaf 2"
str(x)
extract_fun(x)
*/
----------------Contact
Details:-------------------------------------------------------
Contact me: Tal.Galili at gmail.com |
Read me: www.talgalili.com (Hebrew) | www.biostatistics.co.il (Hebrew) |
www.r-statistics.com (English)
----------------------------------------------------------------------------------------------
On Tue, Jul 23, 2013 at 3:23 PM, Romain Francois
<romain at r-enthusiasts.com>wrote:
Hello Tal,
I'm trying to express this with the tools available in Rcpp 0.10.3. (And
adding some tools for later versions too, like is<>).
Here is how I would do the first problem:
First break down into functions. We need :
- something that tells me if a given R object is a list. With Rcpp devel,
we could use is<List> but for now we can write it as:
bool is_list(RObject x){
return TYPEOF(x) == VECSXP ;
}
I've added the is<> so that you don't need to know about TYPEOF or VECSXP.
But here we are essentially mimicking typeof( x ) == "list"
- We need something to tell me if something is a single string:
bool is_string(RObject x){
return TYPEOF(x) == STRSXP && Rf_length(x) == 1 ;
}
agai, with Rcpp devel, we could express this like this: is<String>( x )
instead.
- We need something that tells if an object has a type attribute that is
equal to fun. R lets us do that easily, but we have to pay that flexibility
in C++. What I came up with is this:
bool is_fun(RObject x){
// is this a numeric vector
if( TYPEOF(x) != REALSXP ) return false ;
// is the type attribute a string ?
if( !is_string( x.attr("type") ) ) return false ;
// test the string
String type = x.attr( "type" ) ;
return type == "fun" ;
}
- Then, we need a recursive function that goes through elements of a list.
For collecting results, I'm choosing to pass a std::vector by reference. So
there are two things to learn here:
- pass by reference
- std::vector
you'll find many resources online to teach you these things.
void process( List data, std::vector<double>& results ){
for( int i=0; i<data.size(); i++){
if( is_list( data[i] ) ){
// recurse
process( data[i], results ) ;
} else if( is_fun( data[i] ) ){
// we want to collect them. we can use the NumericVector class
// wince we know thius is a numeric vector.
// (it is tested in is_fun)
NumericVector x = data[i] ;
// loop through the values and add them to the results vector
for( int j=0; j<x.size(); j++){
results.push_back( x[j] ) ;
}
} // else do nothing
}
}
- Finally, we need something that you can call from R. It takes a list as
input, and returns a numeric vector.
// [[Rcpp::export]]
NumericVector extract_fun(List x){
std::vector<double> results ;
process(x, results) ;
return wrap(results) ;
}
Here is the full script:
#include <Rcpp.h>
using namespace Rcpp ;
bool is_list(RObject x){
return TYPEOF(x) == VECSXP ;
}
bool is_string(RObject x){
return TYPEOF(x) == STRSXP && Rf_length(x) == 1 ;
}
bool is_fun(RObject x){
if( TYPEOF(x) != REALSXP ) return false ;
if( !is_string( x.attr("type") ) ) return false ;
String type = x.attr( "type" ) ;
return type == "fun" ;
}
void process( List data, std::vector<double>& results ){
for( int i=0; i<data.size(); i++){
if( is_list( data[i] ) ){
// recurse
process( data[i], results ) ;
} else if( is_fun( data[i] ) ){
// we want to collect them. we can use the NumericVector class
// wince we know thius is a numeric vector.
// (it is tested in is_fun)
NumericVector x = data[i] ;
// loop through the values and add them to the results vector
for( int j=0; j<x.size(); j++){
results.push_back( x[j] ) ;
}
} // else do nothing
}
}
// [[Rcpp::export]]
NumericVector extract_fun(List x){
std::vector<double> results ;
process(x, results) ;
return wrap(results) ;
}
/*** R
x <- list(a = 1, b = 2, c = list(ca = 3, cb = 4, 5), 6)
attr(x[[1]], "type") = "fun"
attr(x[[3]][[1]], "type") = "fun"
x
extract_fun(x)
*/
You should be able to sourceCpp it and get the expected result.
I let you do 2 and 3 as an exercize with what you learn from this.
Hints:
- For 2). you don't need to collect results, so your process can look like
this:
void process( List data ){
// ...
}
I let you update the body to do what you wanted
- For 3). There are several ways to do this in C++. you could use a
reference to an int, a static variable within the function. You could even
use some data that lives in an R environment, using the Environment class.
Whatever you come up with, feel free to share. Those examples are nice
examples of something that is relatively easy to do when you start to be
Rcpp fluent, but not so easy otherwise.
Romain
Le 20/07/13 18:44, Tal Galili a ?crit :
Hello dear Rcpp users,
First - I'd like to say that I took Hadley and Romain's workshop at the
useR conference this year, and I am very excited about trying out Rcpp -
this project looks AMAZING.
Second - this is my first post, and I apologize if my question is too
basic. To my defense, I tried looking through this mailing list /
googled before asking, and read through Hadley's github chapter on Rcpp.
The questions:
I am looking to understand better how List objects can be navigated,
their elements accessed, and manipulated - using Rcpp.
For example, here is an R list object:
x <- list(a = 1, b = 2, c = list(ca = 3, cb = 4, 5), 6)
attr(x[[1]], "type") = "fun"
attr(x[[3]][[1]], "type") = "fun"
x
I would like to create two types of functions:
1) A function that will go through "x" and will *_RETURN_* all of the
elements within it that are of type "fun".
In R I would do it like this:
return_fun <- function(x) {
fun_nubmers <- numeric()
for(i in seq_along(x)) {
if(class(x[[i]]) == "list") {
fun_nubmers <- c(fun_nubmers, return_fun(x[[i]]))
} else {
if(!is.null(attr(x[[i]], "type"))) {
if(attr(x[[i]], "type") == "fun") fun_nubmers <-
c(fun_nubmers, x[[i]])
}
}
}
return fun_nubmers
}
return_fun(x) # output: 1 3
But in Rcpp there are many parts to this R function that I don't know
how to do. I don't know how to access the attributes of a sub-element
within a List, I don't know how to check if that attribute is null or
not, etc. So any suggestions on either reading material (or better yet -
an example of how this function might be created in Rcpp would be great.
2) A function that will go through "x" and will *_CHANGE_* all of the
elements within it that are of type "fun". For example, adding 1 to them.
In R I would do it like this:
add1_fun <- function(x) {
for(i in seq_along(x)) {
if(class(x[[i]]) == "list") {
x[[i]] <- add1_fun(x[[i]])
} else {
if(!is.null(attr(x[[i]], "type"))) {
if(attr(x[[i]], "type") == "fun") x[[i]] <- x[[i]] + 1
}
}
}
x
}
add1_fun(x)
return_fun(x) # output: 1 3
return_fun(add1_fun(x) ) # output: 2 4
3) Is it possible to work with some "global" variable from within a
recursive Rcpp function?
For example:
count_till_5 <- function() {
if(!exists("global_var")) global_var = 0
if(global_var <5) {
global_var <<- global_var+1
count_till_5()
}
}
count_till_5()
global_var
Is there a way to create something like this with Rcpp?
Thanks in advance for any help.
With regards,
Tal
-- Romain Francois Professional R Enthusiast +33(0) 6 28 91 30 30 R Graph Gallery: http://gallery.r-enthusiasts.**com<http://gallery.r-enthusiasts.com> blog: http://blog.r-enthusiasts.com |- http://bit.ly/13SrjxO : highlight 0.4.2 `- http://bit.ly/10X94UM : Mobile version of the graph gallery
-------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.r-forge.r-project.org/pipermail/rcpp-devel/attachments/20130816/da687aa3/attachment-0001.html>