[Rcpp-devel] Forcing a shallow versus deep copy

[romain at r-enthusiasts.com]

These __are__ similar. The difference is in the classes themselves. 
Rcpp classes are proxy classes so C++ copy mechanism does not apply to 
them. arma classes are proper c++ classes, so C++ semantics apply.

I'm at useR right now, so I can't really work on this. I'll submit at 
least ideas later.

Romain


Le 2013-07-11 15:34, Changi Han a écrit :
> I am sure there are better ways to achieve the goal. I would suggest
> that these two be similar if possible. I think the naive expectation
> is for them to be consistent.
>
> // [[Rcpp::export]]
>
> stuff function(Rcpp::stuff) {
> }
>
> // [[Rcpp::export]]
>
> stuff function(arma::stuff) {
>  }
>
> Thank you again. Cheers.
>
> On Thu, Jul 11, 2013 at 9:22 PM, <romain at r-enthusiasts.com [3]> 
> wrote:
>
>> Hello,
>>
>> This comes up every now and then, I think we can find a syntax to
>> initiate an arma::mat that would allow what you want.
>>
>> It is not likely it will come via attributes. The idea is to keep
>> them simple. The solutions I see below would eventually lead to
>> clutter, and we are heading in the less clutter direction.
>>
>> Ill think about it and propose something.
>>
>> Romain
>>
>> Le 2013-07-11 14:32, Changi Han a écrit :
>>
>>> Hello,
>>>
>>> I think I (superficially) understand the difference between:
>>>
>>> // [[Rcpp::export]]
>>> double sum1(Rcpp::NumericMatrix M) {
>>>     arma::mat A(M.begin(), M.rows(), M.cols(), false);
>>>      return sum(sum(A));
>>> }
>>>
>>> // [[Rcpp::export]]
>>> double sum2(arma::mat A) {
>>>     return sum(sum(A));
>>> }
>>>
>>> Partly out of laziness, partly because sum2 is more elegant, and
>>> partly to avoid namespace pollution, I was wondering if there is
>>> a way
>>> to "force" a "shallow" copy in sum2.
>>>
>>> If not, then may I submit a low priority feature request. An
>>> attribute? Some thing like:
>>>
>>> // [[Rcpp::export]]
>>> double sum2(arma::mat A) {
>>>     // [[ Rcpp::shallow ( A ) ]]
>>>      return sum(sum(A));
>>> }
>>>
>>> Or (akin to C++11 generalized attributes)
>>>
>>> // [[Rcpp::export]] { [[ Rcpp::shallow ( A ) ]] }
>>> double sum2(arma::mat A) {
>>>     return sum(sum(A));
>>>  }
>>>
>>> An alternative is to have an argument in sourceCpp that takes a
>>> list/vector of objects that are to be shallow or deep copied.
>>>
>>> For example in sum1, if M is changed within the function before
>>> casting to the arma::mat, then might be cleaner to add M to a
>>> list/vector of objects to be deep copied rather than cloning M
>>> within
>>> sum1: leads to one fewer variable name.
>>>
>>> Just a thought. I can certainly live with the additional step. As
>>> always, thanks for all the Rcpp goodness.
>>>
>>> Cheers,
>>> Changi Han
>>
>> _______________________________________________
>> Rcpp-devel mailing list
>> Rcpp-devel at lists.r-forge.r-project.org [1]
>>
> 
> https://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel
>> [2]
>
>
>
> Links:
> ------
> [1] mailto:Rcpp-devel at lists.r-forge.r-project.org
> [2] 
> https://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel
> [3] mailto:romain at r-enthusiasts.com