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
______________________________________________
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
