From mtmorgan at fredhutch.org  Mon Mar  2 21:24:12 2015
From: mtmorgan at fredhutch.org (Martin Morgan)
Date: Mon, 02 Mar 2015 12:24:12 -0800
Subject: [Rd] R-devel does not update the C++ returned variables
In-Reply-To: <21748.48260.625372.931074@max.nulle.part>
References: <CAHyAz7TOELUyX2XW=8Abvuz2tU0_ZXVuyx-B84RBk7TQyM-mAA@mail.gmail.com>	<54F45105.40608@gmail.com>	<CAHyAz7QvAyL-KgKp0B6pk=RDHAQs2LHeGS48HvATqZnbuoAfww@mail.gmail.com>	<54F46F15.3030901@gmail.com>	<21748.30477.886575.819346@max.nulle.part>	<21748.33727.92491.976456@stat.math.ethz.ch>
	<21748.48260.625372.931074@max.nulle.part>
Message-ID: <54F4C6EC.1060205@fredhutch.org>

On 03/02/2015 11:39 AM, Dirk Eddelbuettel wrote:
>
> On 2 March 2015 at 16:37, Martin Maechler wrote:
> |
> | > On 2 March 2015 at 09:09, Duncan Murdoch wrote:
> | > | I generally recommend that people use Rcpp, which hides a lot of the
> | > | details.  It will generate your .Call calls for you, and generate the
> | > | C++ code that receives them; you just need to think about the real
> | > | problem, not the interface.  It has its own learning curve, but I think
> | > | it is easier than using the low-level code that you need to work with .Call.
> |
> | > Thanks for that vote, and I second that.
> |
> | > And these days the learning is a lot flatter than it was a decade ago:
> |
> | > R> Rcpp::cppFunction("NumericVector doubleThis(NumericVector x) { return(2*x); }")
> | > R> doubleThis(c(1,2,3,21,-4))
> | > [1]  2  4  6 42 -8
> | > R>
> |
> | > That defined, compiled, loaded and run/illustrated a simple function.
> |
> | > Dirk
> |
> | Indeed impressive,  ... and it also works with integer vectors
> | something also not 100% trivial when working with compiled code.
> |
> | When testing that, I've went a step further:
>
> As you may know, int can be 'casted up' to double which is what happens
> here.  So in what follows you _always_ create a copy from an int vector to a
> numeric vector.
>
> For pure int, use eg
>
>      Rcpp::cppFunction("IntegerVector doubleThis(IntegeerVector x) { return(2*x); }")
>
> and rename the function names as needed to have two defined concurrently.

avoiding duplication, harmless in the doubleThis() case, comes at some 
considerable hazard in general

 > Rcpp::cppFunction("IntegerVector incrThisAndThat(IntegerVector x) { x[0] += 
1; return x; }")
 > x = y = 1:5
 > incrThisAndThat(x)
[1] 2 2 3 4 5
 > x
[1] 2 2 3 4 5
 > y
[1] 2 2 3 4 5

(how often this happens in the now relatively large number of user-contributed 
packages using Rcpp?). It seems like 'one-liners' should really encourage 
something safer (sometimes at the expense of 'speed'),

   Rcpp::cppFunction("IntegerVector doubleThis(const IntegerVector x) { return x 
* 2; }")

   Rcpp::cppFunction("std::vector<int> incrThis(std::vector<int> x) { x[0] += 1; 
return x; }")

or that Rcpp should become more careful (i.e., should not allow!) modifying 
arguments with NAMED != 0.

Martin (Morgan)

>
> Dirk
>
> |
> | ##---- now "test":
> | require(microbenchmark)
> | i <- 1:10
> | (mb <- microbenchmark(doubleThis(i), i*2, 2*i, i*2L, 2L*i, i+i, times=2^12))
> | ## Lynne (i7; FC 20), R Under development ... (2015-03-02 r67924):
> | ## Unit: nanoseconds
> | ##           expr min  lq      mean median   uq   max neval cld
> | ##  doubleThis(i) 762 985 1319.5974   1124 1338 17831  4096   b
> | ##          i * 2 124 151  258.4419    164  221 22224  4096  a
> | ##          2 * i 127 154  266.4707    169  216 20213  4096  a
> | ##         i * 2L 143 164  250.6057    181  234 16863  4096  a
> | ##         2L * i 144 177  269.5015    193  237 16119  4096  a
> | ##          i + i 152 183  272.6179    199  243 10434  4096  a
> |
> | plot(mb, log="y", notch=TRUE)
> | ## hmm, looks like even the simple arithm. differ slightly ...
> | ##
> | ## ==> zoom in:
> | plot(mb, log="y", notch=TRUE, ylim = c(150,300))
> |
> | dev.copy(png, file="mbenchm-doubling.png")
> | dev.off() # [ <- why do I need this here for png ??? ]
> | ##--> see the appended *png graphic
> |
> | Those who've learnt EDA or otherwise about boxplot notches, will
> | know that they provide somewhat informal but robust pairwise tests on
> | approximate 5% level.
> | >From these, one *could* - possibly wrongly - conclude that
> | 'i * 2' is significantly faster than both 'i * 2L' and also
> | 'i + i' ---- which I find astonishing, given that  i is integer here...
> |
> | Probably no reason for deep thoughts here, but if someone is
> | enticed, this maybe slightly interesting to read.
> |
> | Martin Maechler, ETH Zurich
> |
> | [DELETED ATTACHMENT mbenchm-doubling.png, PNG image]
>


-- 
Computational Biology / Fred Hutchinson Cancer Research Center
1100 Fairview Ave. N.
PO Box 19024 Seattle, WA 98109

Location: Arnold Building M1 B861
Phone: (206) 667-2793



[Rd] R-devel does not update the C++ returned variables
Martin Morgan