Adicionei 6-Rcpp_CUDA.Rmd

Author: Jose Storopoli

1-Porque_CPP.Rmd

@@ -57,14 +57,19 @@ int addCpp(int x, int y, int z){
 addCpp(10, 17, 31)
 ```
 
-Comparando tempo de execução (em ns) com a função `mark()` do pacote `{bench}`:
+Comparando tempo de execução com a função `mark()` do pacote `{bench}`:
 
-```{r bench_add}
-bench::mark(
+```{r bench-add, message=FALSE}
+b1 <- bench::mark(
   R   = addR(10, 17, 31),
   Cpp = addCpp(10, 17, 31),
-  time_unit = "ns"
+  relative = TRUE
 )
+b1
+```
+
+```{r fig-bench-add, echo=FALSE, fig.cap='Benchmark da função soma: R vs C++'}
+ggplot2::autoplot(b1, "violin")
 ```
 
 Aqui vocês vem que C++ não tem nenhuma vantagem sobre R: é mais verboso, chato de escrever e ainda é mais lenta!
@@ -117,15 +122,25 @@ NumericMatrix gibbsCpp(int N, int thin) {
 )
 ```
 
-E vamos para o benchmark (em µs):
-
-```{r bench_gibbs}
-bench::mark(
-  R = gibbsR(100, 10),
-  Cpp = gibbsCpp(100, 10),
-  check = FALSE,
-  time_unit = "us"
+E vamos para o benchmark comparando alguns tamanhos de inputs:
+
+```{r bench-gibbs, message=FALSE}
+b2 <- bench::press(
+  N = 10^c(2:3),
+{
+  bench::mark(
+    R = gibbsR(N, 10),
+    Cpp = gibbsCpp(N, 10),
+    check = FALSE,
+    relative = TRUE
+  )
+}
 )
+b2
+```
+
+```{r fig-bench-gibbs, echo=FALSE, fig.cap='Benchmarks do Amostrador de Gibbs: R vs C++'}
+ggplot2::autoplot(b2, "violin")
 ```
 
 No meu computador `gibbsCpp()` executa 20x mais rápido que `gibbsR()`!

2-Rcpp.Rmd

@@ -182,14 +182,14 @@ A tabela abaixo apresenta a correspondência dos tipos de dados entre R/`{Rcpp}`
 library(gt)
 library(dplyr)
 tibble::tribble(
-      ~`Tipo de Variável`,   ~`Vetor R`,                     ~`Vetor Rcpp`,                     ~`Matriz Rcpp`, ~`Escalar Rcpp`, ~`Escalar C++`,
-   "Lógica",   "logical",                  "LogicalVector",                  "LogicalMatrix",          "-",        "bool",
-   "Inteiro",   "integer",                  "IntegerVector",                  "IntegerMatrix",          "-",         "int",
-      "Real",   "numeric",                  "NumericVector",                  "NumericMatrix",          "-",      "double",
-   "Complexo",   "complex",                  "ComplexVector",                  "ComplexMatrix",   "Rcomplex",     "complex",
-    "String", "character", "CharacterVector (StringVector)", "CharacterMatrix (StringMatrix)",     "String",      "std::string",
-      "Date",      "Date",                     "DateVector",                              "-",       "Date",           "-",
-  "Datetime",   "POSIXct",                 "DatetimeVector",                              "-",   "Datetime",      "time_t"
+      ~`Tipo de Variável`,   ~`Vetor R`,                     ~`Vetor Rcpp`,                     ~`Matriz Rcpp`, ~`Escalar Rcpp`, ~`Missing Rcpp`, ~`Escalar C++`,
+   "Lógica",   "logical",                  "LogicalVector",                  "LogicalMatrix",          "-",        "NA_LOGICAL", "bool",
+   "Inteiro",   "integer",                  "IntegerVector",                  "IntegerMatrix",          "-",        "NA_INTEGER", "int",
+      "Real",   "numeric",                  "NumericVector",                  "NumericMatrix",          "-",      "NA_REAL", "double",
+   "Complexo",   "complex",                  "ComplexVector",                  "ComplexMatrix",   "Rcomplex",     "-", "complex",
+    "String", "character", "CharacterVector (StringVector)", "CharacterMatrix (StringMatrix)",     "String",     "NA_STRING", "std::string",
+      "Date",      "Date",                     "DateVector",                              "-",       "Date",         "-",  "-",
+  "Datetime",   "POSIXct",                 "DatetimeVector",                              "-",   "Datetime",     "-", "time_t"
   ) %>%
   mutate_all(~stringr::str_glue("`{.}`")) %>% 
   gt() %>% 
@@ -341,6 +341,24 @@ DataFrame df = DataFrame::create(v1, v2);
 DataFrame df = DataFrame::create( Named("V1") = v1 , _["V2"] = v2 );
 ```
 
+### `{Rcpp}` `tibble`
+
+Para retornar uma `tibble` do `{tidyverse}` com o `{Rcpp}` é só você notar que uma `tibble` não é nada mais que um `data.frame` com algumas classes extras:
+
+```{r tibble}
+df <- tibble::tibble()
+class(df)
+```
+
+E aí é só adicionar essas classes num `DataFrame` do `{Rcpp}`:
+
+```cpp
+DataFrame df = DataFrame::create( Named("V1") = v1 , _["V2"] = v2 );
+df.attr("class") = CharacterVector::create("tbl_df", "tbl", "data.frame");
+```
+
+Pronto seu objeto `DataFrame` quando for retornado ao R será uma `tibble` do `{tidyverse}`.
+
 ## `{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). 
@@ -365,19 +383,28 @@ NumericVector mat_mul(const NumericVector& A, const NumericVector& B) {
 }
 ```
 
-```{r bench-mat_mul}
-n <- 10^3
-X <- matrix(rnorm(n * n), nrow = n)
-
-bench::mark(
-  R = X %*% X,
-  Cpp = mat_mul(X, X),
-  check = FALSE
+```{r bench-mat_mul, message=FALSE}
+b1 <- bench::press(
+  n = 10^c(2:3),
+  {
+    X = matrix(rnorm(n * n), nrow = n)
+    bench::mark(
+      R = X %*% X,
+      Cpp = mat_mul(X, X),
+      check = FALSE,
+      relative = TRUE
+  )}
 )
+b1
 ```
 
 
-Sucesso! Ganho de 700x `r emo::ji("exploding_head")` para uma matriz de dimensão `r format(n, big.mark = ".", decimal.mark = ",")` x `r format(n, big.mark = ".", decimal.mark = ",")`!
+```{r figmatmul, echo=FALSE, fig.cap='Benchmarks de Multiplicação de Matriz: R vs C++'}
+ggplot2::autoplot(b1, "violin")
+```
+
+
+Sucesso! Ganho de 200x `r emo::ji("exploding_head")`
 
 ## Usando a biblioteca padrão C++11 STL no `{Rcpp}`
 
@@ -441,27 +468,37 @@ double sum_of_squares_rcpp_sugar(NumericVector v){
 }
 ```
 
-```{r bench_sum_of_squares}
+```{r bench-sum_of_squares, message=FALSE}
 set.seed(123)
-n <- 1000
-v <- rnorm(n)
-bench::mark(
-  R = sum_of_squares_R(v),
-  rcpp = sum_of_squares_rcpp(v),
-  rcpp20 = sum_of_squares_rcpp20(v),
-  rcppsugar = sum_of_squares_rcpp_sugar(v),
-  check = FALSE,
-  time_unit = "us"
-)
+
+b2 <- bench::press(
+  n = 10^c(1:4),
+  {
+    v = rnorm(n)
+    bench::mark(
+      R = sum_of_squares_R(v),
+      rcpp = sum_of_squares_rcpp(v),
+      rcpp20 = sum_of_squares_rcpp20(v),
+      rcppsugar = sum_of_squares_rcpp_sugar(v),
+      check = FALSE,
+      relative = TRUE
+    )
+})
+b2
 ```
 
-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.
+```{r figss, echo=FALSE, fig.cap='Benchmarks de Soma dos Quadrados: R vs alternativas C++'}
+ggplot2::autoplot(b2, "violin")
+```
+
+
+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.
 
 ## `{Rcpp}` e Boost
 
 [Boost](https://www.boost.org) é um conjunto de bibliotecas para a linguagem de programação C++ que fornece suporte para tarefas e estruturas como álgebra linear, geração de números pseudo-aleatórios, multithreading, processamento de imagem, expressões regulares e teste de unidade. Ele contém ~~uma porrada~~ 164 bibliotecas individuais (versão 1.75) e sua versão inicial foi lançada em 1999.
 
-A maioria das bibliotecas Boost são licenciadas sob a Licença de Software Boost, projetada para permitir que Boost seja usado com projetos de software proprietários e gratuitos. Muitos dos fundadores da Boost estão no comitê internacional de padrões C++, e várias bibliotecas Boost foram aceitas para incorporação no padrão C++11 (por exemplo, smart pointers, `thread`, `regex`, `random`, `ratio`, `tuple`) e no padrão C ++ 17 (por exemplo, `filesystem`, `any`, `optional`, `variant`, `string_view`).
+A maioria das bibliotecas Boost são licenciadas sob a Licença de Software Boost, projetada para permitir que Boost seja usado com projetos de software proprietários e gratuitos. Muitos dos fundadores da Boost estão no comitê internacional de padrões C++, e várias bibliotecas Boost foram aceitas para incorporação no padrão C++11 (por exemplo, smart pointers, `thread`, `regex`, `random`, `ratio`, `tuple`) e no padrão C++17 (por exemplo, `filesystem`, `any`, `optional`, `variant`, `string_view`).
 
 Antes de usar o Boost no `{Rcpp}` certifique-se que você tem o Boost instalado no seu sistema operacional:
 
@@ -516,15 +553,22 @@ int boostGCD(int& a, int& b) {
 }
 ```
 
-```{r bench_GCD}
+```{r bench-GCD, message=FALSE}
 a <- 7919
 b <- 7412
-bench::mark(
+b3 <- bench::mark(
   R = rGCD(a, b),
   cpp = cppGCD(a, b),
-  boost = boostGCD(a, b)
+  boost = boostGCD(a, b),
+  relative = TRUE
 )
+b3
 ```
+
+```{r figGCD, echo=FALSE, fig.cap='Benchmarks de Máximo Divisor Comum: R vs C++'}
+ggplot2::autoplot(b3, "violin")
+```
+
 Aqui eu escolhi um número primo bem grande, 7189, e um número aleatório próximo dele, 7412. Como vocês podem ver a solução usando a biblioteca `boost::integer` é 4,5x mais rápida que uma implementação em R e similar com a implementação de C++17.
 
 ## `{Rcpp}` e Rmarkdown

3-RcppEigen_RcppArmadillo.Rmd

@@ -444,29 +444,43 @@ MatrixXd mat_mul_eigen(const MatrixXd& A, const MatrixXd& B){
 }
 ```
 
-```{r bench-mat_mul}
-n <- 10^3
-X <- matrix(rnorm(n * n), nrow = n)
-
-bench::mark(
-  Rcpp = mat_mul(X, X),
-  arma = mat_mul_arma(X, X),
-  eigen = mat_mul_eigen(X, X),
-  check = FALSE
-)
+```{r bench-mat_mul, message=FALSE, warning=FALSE}
+b1 <- bench::press(
+  n = 10^c(1:3),
+  {
+    X = matrix(rnorm(n * n), nrow = n)
+    bench::mark(
+      Rcpp = mat_mul(X, X),
+      arma = mat_mul_arma(X, X),
+      eigen = mat_mul_eigen(X, X),
+      check = FALSE,
+      relative = TRUE
+    )
+})
+b1
+```
+
+```{r figmatmul, echo=FALSE, fig.cap='Benchmarks de Multiplicação de Matriz: `Rcpp` vs `Armadillo` vs `Eigen`'}
+ggplot2::autoplot(b1, "violin")
 ```
 
+
 No meu computador `{RcppEigen}` é mais rápido que `{RcppArmadillo}`, mas ambos são mais lentos que uma implementação simples com `{Rcpp}`. 
 
 ### Exemplo -- Matriz Esparsa
 
 Vamos usar `mat_sparse` criada que possui dimensão `r format(dim(mat_sparse)[1], big.mark = ".", decimal.mark = ",")` x `r format(dim(mat_sparse)[2], big.mark = ".", decimal.mark = ",")` e tomar a raiz quadrada de todos os elementos.
 
-```{r bench-sparse_sqrt}
-bench::mark(
+```{r bench-sparse_sqrt, warning=FALSE, message=FALSE}
+b2 <- bench::mark(
   arma = sqrt_eigen(mat_sparse),
-  eigen = sqrt_eigen(mat_sparse)
+  eigen = sqrt_eigen(mat_sparse),
+  relative = TRUE
 )
+b2
+```
+```{r figsparsesqrt, echo=FALSE, fig.cap='Benchmarks de Matriz Esparsa: `Armadillo` vs `Eigen`'}
+ggplot2::autoplot(b2, "violin")
 ```
 
 Novamente `Eigen` é um pouco mais rápida que `Armadillo`, mas a diferença é pequena.
@@ -528,15 +542,21 @@ Rcpp::List fast_lm_eigen(const VectorXd& y, const MatrixXd& X) {
 }
 ```
 
-```{r bench-fast_lm}
+```{r bench-fast_lm, warning=FALSE, message=FALSE}
 y <- log(trees$Volume)
 X <- cbind(1, log(trees$Girth))
-bench::mark(
+b3 <- bench::mark(
   R = lm(y ~ X),
   arma = fast_lm_arma(y, X),
   eigen = fast_lm_eigen(y, X),
-  check = FALSE
+  check = FALSE,
+  relative = TRUE
 )
+b3
+```
+
+```{r figfastlm, echo=FALSE, fig.cap='Benchmarks de Regressão Linear: R vs `Armadillo` vs `Eigen`'}
+ggplot2::autoplot(b3, "violin")
 ```
 
 Tanto `Eigen` quanto `Armadillo` são rápidos! Quase 100x mais rápidos `r emo::ji("exploding_head")`. Novamente a diferença entre `Eigen` e `Armadillo` é pequena.