Atualizações Dirk de Rcpp Sugar.

Author: Jose Storopoli

1-Porque_CPP.Rmd

@@ -226,7 +226,7 @@ A figura \@ref(fig:cppfunction) mostra a anatomia de uma função em C++. Ela é
 * **Tipo de Retorno**: toda função em C++ deve especificar, antes do seu nome, o tipo de dado que é retornado pela função.
 * **Valor de Retorno**: toda função em C++ deve especificar explicitamente qual valor retornar com um `return`. No R podemos ser mais desleixados pois o valor de retorno será sempre a ultima declaração da função. Em C++ isto não funciona. A lógica de C++ é que a função termina quando ela atinge o primeiro `return` e retorna o dado/variável especificado(a). 
 
-```{r cppfunction, echo=FALSE, fig.cap='Anatomia de uma função em C++'}
+```{r cppfunction, echo=FALSE, fig.cap='Anatomia de uma função em C++. Figura adaptada da Vinheta Oficial Introdutória do `{Rcpp}` de Dirk Eddelbuettel'}
 knitr::include_graphics("images/cpp_function.png")
 ```
 

2-Rcpp.Rmd

@@ -341,6 +341,10 @@ DataFrame df = DataFrame::create(v1, v2);
 DataFrame df = DataFrame::create( Named("V1") = v1 , _["V2"] = v2 );
 ```
 
+## `{Rcpp}` Sugar
+
+Além dos tipos de dados, `{Rcpp}` também tem uma ampla gama de "açúcares" sintáticos (*syntactic sugar*) para as mais variadas operações e funções. Antes de tentar criar algo do zero veja se não há um [`{Rccp}` Sugar para isso já implementado na vinheta](http://dirk.eddelbuettel.com/code/rcpp/Rcpp-sugar.pdf). 
+
 ## Exemplo -- Multiplicação de Matrizes
 
 Está na hora de colocarmos o que vimos em prática. Nesse caso vamos comparar multiplicar duas matrizes usando o R (operador `%*%`) e usando o C++ com `{Rcpp}`.
@@ -387,15 +391,14 @@ Aqui eu vou ser um pouco abusado no exemplo e já vou pular direto para um algor
 
 Soma dos quadrados é algo que ocorre bastante em computação científica, especialmente quando estamos falando de regressão, mínimos quadrados, ANOVA etc. Vamos fazer três implementações de uma função que aceita como parâmetro um vetor de números reais (C++ `double` / R `numeric`) e computa a soma de todos os elementos do vetor elevados ao quadrado:
 
-1. `sum_of_squares_R()`: feita no R com vetorização usando o `{purrr}`.
+1. `sum_of_squares_R()`: feita no R com vetorização.
 2. `sum_of_squares_rcpp()`: feita de maneira ingênua no C++ com dois loops `for` triviais que (1) multiplica cada elemento consigo mesmo e (2) adiciona todos os elementos do vetor à uma variável `double`.
-3. `sum_of_squares_cpp20()`: solução elegante que usa `transform_reduce` para transformar todos os elementos multiplicando-os por si mesmos e ao mesmo tempo somando todos os elementos.
+3. `sum_of_squares_rcpp20()`: solução elegante que usa `transform_reduce` para transformar todos os elementos multiplicando-os por si mesmos e ao mesmo tempo somando todos os elementos.
+4. `sum_of_squares_rcpp_sugar()`: solução usando [`{Rcpp}` Sugar](http://dirk.eddelbuettel.com/code/rcpp/Rcpp-sugar.pdf).
 
 ```{r sum_of_squares_R}
-library(magrittr)
 sum_of_squares_R <- function(v) {
-  purrr::map_dbl(v, ~ .x * .x) %>% 
-    purrr::reduce(`+`)
+  sum(v * v)
 }
 ```
 
@@ -423,14 +426,19 @@ double sum_of_squares_rcpp(NumericVector v){
 }
 
 // [[Rcpp::export]]
-double sum_of_squares_cpp20(const NumericVector v){
+double sum_of_squares_rcpp20(const NumericVector v){
   
   return transform_reduce(v.cbegin(),
                           v.cend(),
                           0L,
                           std::plus{},
                           [] (auto i) {return i * i;});
 }
+
+// [[Rcpp::export]]
+double sum_of_squares_rcpp_sugar(NumericVector v){
+  return(sum(v*v));
+}
 ```
 
 ```{r bench_sum_of_squares}
@@ -440,13 +448,14 @@ v <- rnorm(n)
 bench::mark(
   R = sum_of_squares_R(v),
   rcpp = sum_of_squares_rcpp(v),
-  cpp20 = sum_of_squares_cpp20(v),
+  rcpp20 = sum_of_squares_rcpp20(v),
+  rcppsugar = sum_of_squares_rcpp_sugar(v),
   check = FALSE,
   time_unit = "us"
 )
 ```
 
-Mais um sucesso! Ganho de 600x `r emo::ji("exploding_head")` para um vetor com `r format(n, big.mark = ".", decimal.mark = ",")` elementos! O mais impressionante é que uma solução simples e ingênua com dois loops `for` em C++ ficou quase tão rápida quanto uma solução C++ usando `transform_reduce()`!
+Aqui vemos como a vetorização do R funciona muito bem. É mais rápida que quase todas as implementações em `{Rcpp}`, exceto quando usamos o [`{Rcpp}` Sugar](http://dirk.eddelbuettel.com/code/rcpp/Rcpp-sugar.pdf) já que temos um ganho de 2x para um vetor com `r format(n, big.mark = ".", decimal.mark = ",")` elementos.
 
 ## `{Rcpp}` e Boost
 
@@ -555,6 +564,7 @@ Diversos materiais me ajudaram a aprender e criar esse conjunto de tutoriais de
 * Livro [Seamless R and C++ Integration with Rcpp](http://www.rcpp.org/book/) do criador do ecossitema `{Rcpp}` Dirk Eddelbuettel.
 * [Capítulo 25 -- Rewriting R code in C++](https://adv-r.hadley.nz/rcpp.html) do livro Advanced R do Hadley Wickham.
 * [Galeria de exemplos de `{Rcpp}`](https://gallery.rcpp.org).
+* [Vinheta do `{Rcpp}` Sugar](http://dirk.eddelbuettel.com/code/rcpp/Rcpp-sugar.pdf).
 * Livro [Rcpp for Everyone](https://teuder.github.io/rcpp4everyone_en/) do Masaki E. Tsuda.
 * [Documentação Não-Oficial](https://thecoatlessprofessor.com/programming/cpp/unofficial-rcpp-api-documentation/) de `{Rcpp}` do James Balamuta (também conhecido como TheCoatlessProfessor).
 * Vídeo do [Dirk Eddelbuettel na conferência useR! 2020 sobre `{Rcpp}`](https://youtu.be/57H34Njrns4).

5-cpp11.Rmd

@@ -133,50 +133,54 @@ tibble::tribble(
 
 Vamos reutilizar o exemplo `sum_of_squares` do [tutorial 2. Como incorporar C++ no R - {Rcpp}](2-Rcpp.html).
 
-Soma dos quadrados é algo que ocorre bastante em computação científica, especialmente quando estamos falando de regressão, mínimos quadrados, ANOVA etc. Vamos comparar a função usando dois loops `for`^[`{cpp11}` ainda não possui suporte à funcionalidades de C++20 -- `std::transform_reduce()`.] tanto no `{Rcpp}` quanto no `{cpp11}`. Lembrando que esta implementação será uma função que aceita como parâmetro um vetor de números reais (C++ `double` / R `numeric`) e computa a soma de todos os elementos do vetor elevados ao quadrado.
+Soma dos quadrados é algo que ocorre bastante em computação científica, especialmente quando estamos falando de regressão, mínimos quadrados, ANOVA etc. Vamos comparar a função usando um [`std::acummulate`](https://en.cppreference.com/w/cpp/algorithm/accumulate) de C+11 STL^[`{cpp11}` ainda não possui suporte à funcionalidades de C++20 -- `std::transform_reduce()`.] tanto no `{Rcpp}` quanto no `{cpp11}`. Lembrando que esta implementação será uma função que aceita como parâmetro um vetor de números reais (C++ `double` / R `numeric`) e computa a soma de todos os elementos do vetor elevados ao quadrado.
+
+Para ser uma comparação justa, vamos usar também do [tutorial 2. Como incorporar C++ no R - {Rcpp}](2-Rcpp.html), a função `sum_of_squares_rcpp_sugar()` que usa [`{Rcpp}` Sugar](http://dirk.eddelbuettel.com/code/rcpp/Rcpp-sugar.pdf).
 
 ```{Rcpp sum_of_squares_rcpp}
 #include <Rcpp.h>
-// [[Rcpp::plugins("cpp11")]]
+#include <numeric>
 
 using namespace Rcpp;
 
+// [[Rcpp::plugins("cpp11")]]
+
 // [[Rcpp::export]]
 double sum_of_squares_rcpp(NumericVector v){
   double sum_of_elems = 0;
   
-  // primeiro for multiplicando cada elemento consigo mesmo
-  for(int i=0; i < v.size(); i++){
-    v[i] = v[i] * v[i];
-  }
-  
-  // segundo for somando todos os elementos
-  for(auto it = v.cbegin(); it != v.cend(); ++it)
-    sum_of_elems += *it;
+  sum_of_elems += std::accumulate(v.cbegin(),
+                                  v.cend(),
+                                  0.0,
+                                  [] (double i, double j) {return i + (j * j);});
   return sum_of_elems;
 }
+
+// [[Rcpp::export]]
+double sum_of_squares_rcpp_sugar(NumericVector v){
+  return(sum(v*v));
+}
 ```
 
 
 ```{cpp11 sum_of_squares_cpp11}
 #include "cpp11/doubles.hpp"  // aqui usando somente o header doubles
+#include <numeric>
+
 using namespace cpp11;
 namespace writable = cpp11::writable;
 
 
-[[cpp11::register]] double sum_of_squares_cpp11(writable::doubles v){
+[[cpp11::register]] double sum_of_squares_cpp11(doubles v){
   double sum_of_elems = 0;
   
-  // primeiro for multiplicando cada elemento consigo mesmo
-  for(int i=0; i < v.size(); i++){
-    v[i] = v[i] * v[i];
-  }
-  
-  // segundo for somando todos os elementos
-  for(auto it = v.cbegin(); it != v.cend(); ++it)
-    sum_of_elems += *it;
+  sum_of_elems += std::accumulate(v.cbegin(),
+                                  v.cend(),
+                                  0.0,
+                                  [] (double i, double j) {return i + (j * j);});
   return sum_of_elems;
 }
+
 ```
 
 ```{r bench-sum_of_squares}
@@ -186,11 +190,12 @@ v <- rnorm(n)
 bench::mark(
   Rcpp = sum_of_squares_rcpp(v),
   cpp11 = sum_of_squares_cpp11(v),
+  Rcppsugar = sum_of_squares_rcpp_sugar(v),
   check = FALSE,
 )
 ```
 
-Apesar de ser uma nova proposta o `{cpp11}`, pelo menos neste simples benchmark e no meu computador, possui um desempenho bem inferior ao do `{Rcpp}`: 60x mais lerdo...
+Quando usada a biblioteca padrão C++11 STL tanto `{cpp11}` quanto `{Rcpp}` e `{Rcpp}` Sugar, pelo menos neste simples benchmark e no meu computador, possuem um desempenho similar para um vetor com `r format(n, big.mark = ".", decimal.mark = ",")` elementos. É claro que solução do `{Rcpp}` Sugar é muito mais elegante e simples com uma única linhana função.
 
 ## `{cpp11}` e Rmarkdown