07-moreCpp.Rmd

```{R echo = FALSE, warnings = FALSE}
source("include.cpp.r")
includeCppPath <- "../introRcppMore/src/"
```
# Un peu plus de C++ 

Install the package with

```{R eval = FALSE, prompt = TRUE}
devtools::install_github("introRcpp/introRcppMore")
```

Load it with
```{R}
library(introRcppMore)
```

## Pointeurs

Les pointeurs sont un héritage de C. Il s'agit de \og pointer\fg\ vers
l'adresse d'un objet ou une variable. Un pointeur vers un `int` est un `int *`.
Si `p` est un pointeur, `*p` est l'objet à l'adresse pointée par `p`.

Pour obtenir le pointeur vers `x`, on utilise `&x`.

```{R echo = FALSE, results = "asis"}
include.cpp('pointers.cpp')
```

```{r prompt = TRUE, comment = NA}
pointers()
```

Nous avions déjà rencontré des pointeurs sans le savoir : les tableaux
sont des pointeurs ! Plus précisément, si on a déclaré `int a[4]`,
`a` pointe vers le premier élément du tableau, `a+1` vers le second, etc.

```{R echo = FALSE, results = "asis"}
include.cpp('arrays.cpp')
```

```{r prompt = TRUE, comment = NA}
arrays()
```

Notez la différence entre `a` et `a+2` : la taille des `int` est prise en compte 
dans le calcul.

En passant à une fonction un pointeur vers une variable, 
d'une part on permet la modification de cette variable, d'autre part on 
évite la copie de cette variable (intéressant quand on passe des
objets de grande taille).

```{R echo = FALSE, results = "asis"}
include.cpp('swap.cpp')
```

Attention, la fonction `swap` ne peut pas être exportée vers R : les objets
de R ne peuvent être transformés en `int *`, en pointeurs vers des entiers.
Elle est destinée à n'être utilisée que dans notre code C++.

Le mot clef `inline` ci-dessus indique au compilateur qu'on désire que la
fonction soit insérée dans le code aux endroit où elle est utilisée. Cela
économise un appel de fonction...

```{r prompt = TRUE, comment = NA}
demonstrateSwap(12, 14)
demonstrateSwap(14, 12)
```

## Références

Le mécanisme derrière les références est similaire à celui des pointeurs ; la syntaxe est 
plus simple et permet d'éviter de 
promener des étoiles dans tout le code. Une référence à un entier est de type `int &`,
et peut être manipulée directement comme un `int`. On l'initialise à l'aide d'une 
autre variable de type `int`.

```{R echo = FALSE, results = "asis"}
include.cpp('references.cpp')
```

```{r prompt = TRUE, comment = NA}
references()
```

C'est surtout utile pour spécifier les arguments d'une fonction.
Voici ce que devient notre fonction `swap`:

```{R echo = FALSE, results = "asis"}
include.cpp('swap2.cpp')
```

Cette fonction `swap2` ne peut pas plus être exportée que la 
fonction `swap` définie plus haut.

```{r prompt = TRUE, comment = NA}
demonstrateSwap2(12, 14)
demonstrateSwap2(14, 12)
```

### Autres exemples

Un appel `divideByTwo(x)` est équivalent à `x /= 2`. L'utilisation de
cette fonction ne
simplifie pas vraiment le code, mais ce mécanisme pourrait être
utile pour des opérations plus complexes:

```{R echo = FALSE, results = "asis"}
include.cpp('divideByTwo.cpp')
```

```{r prompt = TRUE, comment = NA}
intLog2(17)
```

Une autre utilité est de renvoyer plusieurs valeurs. Bien sûr quand
on utilise `Rcpp` on peut manipuler des vecteurs ou des listes, mais
utiliser des variables passées par référence pour récupérer les résultats
d'un calcul est souvent très commode.

```{R echo = FALSE, results = "asis"}
include.cpp('quadratic.cpp')
```

```{r prompt = TRUE, comment = NA}
demoQuadratic(1,-5,6)
demoQuadratic(1,0,1)
```

## Les objets de Rcpp sont passés par référence

La fonction suivante le démontre : les vecteurs de Rcpp sont passés par référence 
(ou sont des pointeurs, comme vous préférez).
Ceci permet un grand gain de temps, en évitant la copie des données, 
mais a aussi des effets potentiellement indésirables.

```{R echo = FALSE, results = "asis"}
include.cpp('twice.cpp')
```

```{r prompt = TRUE, comment = NA}
x <- seq(0,1,0.1);
x
twice(x)
x # oups
```

De plus, quand on copie un objet en R, comme ci-dessous avec `y <- x`, la recopie des données n'a pas lieu dans un premier
temps. Au début, `y` pointe vers le même objet que `x` ; la recopie n'aura lieu que si on modifie `y`. Quand on utilise
`Rcpp` ce mécanisme n`est plus actif:

```{r prompt = TRUE, comment = NA}
x <- seq(0,1,0.1);
y <- x
twice(y)
x
y
```

La prudence est de mise! Notez qu'on a aussi le comportement suivant:
```{r prompt = TRUE, comment = NA}
x <- 1:5;
x
twice(x)
x 
```
Utiliser `typeof(x)` pour résoudre cette énigme.

À supposer que ce comportement soit indésirable, comment y remédier ?

```{R echo = FALSE, results = "asis"}
include.cpp('twice2.cpp')
```

```{r prompt = TRUE, comment = NA}
x <- seq(0,1,0.1); invisible(twice2(x)); x
x <- seq(0,1,0.1); invisible(twice3(x)); x
```

On peut également modifier « en place » les éléments d'une liste:

```{R echo = FALSE, results = "asis"}
include.cpp('incrementAlpha.cpp')
```

Exemple:

```{r prompt = TRUE, comment = NA}
x <- list( alpha = c(0.1,7), beta = 1:4)
x
incrementAlpha(x)
x
```


## Surcharge

En C++ deux fonctions peuvent avoir le même nom, à condition que le type des
arguments soit différent, 
ce qui permet au compilateur de les différentier. À noter : le type retourné
par la fonction n'est pas pris en compte dans ce mécanisme.

Ceci s'appelle la *surcharge* des fonctions. On a également une surcharge
des opérateurs (comme `+`, `<<`, etc).

**Attention !** On ne peut pas exporter des fonctions surchargées avec Rcpp.
Il faut donc maintenir ce mécanisme dans la partie strictement C++ de votre
code.

Voici un exemple de fonction surchargée.

```{R echo = FALSE, results = "asis"}
include.cpp('d2.cpp')
```

```{r prompt = TRUE, comment = NA}
exampleD2()
```

On peut également avoir des fonctions qui ont le même nom, et un nombre différent d'arguments.

## Templates

Les templates facilitent la réutilisation de code avec des types différents.
Prendre le temps d'utiliser des méthodes propres pour éviter les copier-coller 
dans le code est de toute première importance quand il s'agit de \og maintenir\fg\ le
code.

### Fonctions polymorphes

L'exemple ci-dessous définit un template `d2` ; lors de la compilation
de la fonctions `addition_int` et `addition_double` ce template sera instancié
avec `TYPE = int` puis avec `TYPE = double`.

```{R echo = FALSE, results = "asis"}
include.cpp('d2.h')
include.cpp('exampleTemplate.cpp')
```

Exemple:

```{r prompt = TRUE, comment = NA}
exampleTemplate()
```

Si le compilateur peinait à trouver par quoi il faut remplacer `TYPE`, il serait
possible de préciser en tapant par exemple `d2<float>`. Ce template peut fonctionner
dès que les opérateurs `+` et `*` sont définis. 

```{R echo = FALSE, results = "asis"}
include.cpp('exempleTemplate2.cpp')
```

```{r prompt = TRUE, comment = NA}
exempleTemplate2( c(1,2), c(3,1) )
```

On peut donner un autre exemple en faisant un template pour la fonction `swap`
que nous avions écrite il y a quelques chapitres.

```{R echo = FALSE, results = "asis"}
include.cpp('demonstrateSwap3.cpp')
```

```{r prompt = TRUE, comment = NA}
demonstrateSwap3(12, 14)
demonstrateSwap3(14, 12)
```

**Note :** n'utilisez pas ce template dans votre code, 
C++ a déjà un template `std::swap`, qui est mieux fait que celui-ci ! (Il 
évite la copie). Voir https://en.cppreference.com/w/cpp/algorithm/swap

### Laisser le compilateur s'occuper des types

Une des utilités des templates est de permettre de ne pas trop
se soucier de types « compliqués » comme ceux des fonctions. Ci-dessous
on définit une fonction `numDerivation` qui donne une approximation de
la dérivée de son premier argument.

```{R echo = FALSE, results = "asis"}
include.cpp('derivSquare.cpp')
```

```{r prompt = TRUE, comment = NA}
derivSquare(3)
```

On voit que `numDerivation` prend deux arguments, une fonction `f` et un point `a`,
et donne une approximation de $f'(a)$ en calculant
$$ {f(a+\varepsilon) - f(a-\varepsilon) \over 2\varepsilon} . $$

Quel est le type d'une fonction ?! Nous laissons
au compilateur le soin de remplacer `FTYPE` par la bonne valeur.
Dans notre exemple, lors d'instanciation du template, `TYPE` est remplacé par `double`
et `FTYPE` par `double (*)(double)` (pointeur vers une fonction
qui renvoie un `double` et dont l'argument est un `double`). Un code équivalent serait

```{R echo = FALSE, results = "asis"}
include.cpp('derivSquare.alt')
```


## C++11

Le standard C++11 est maintenant accepté dans les packages R. Pour permettre
la compilation avec les extensions offertes par C++11, 
il faut inclure dans `src/` un fichier `Makevars` contenant
```
PKG_CXXFLAGS = -std=c++11
```


### Les boucles sur un vecteur et `auto`

Parmi les extensions offertes, les plus séduisantes sont sans doute : le mot-clef `auto`, 
qui laisse le compilateur deviner le type, quand le contexte le permet, de façon similaire
à ce qui est fait dans les templates, et les boucles
`for` qui parcourent un vecteur... comme en R.

```{R echo = FALSE, results = "asis"}
include.cpp('countZeroes.cpp')
```

```{r prompt = TRUE, comment = NA}
set.seed(1); a <- sample(0:99, 1e6, TRUE)
countZeroes(a);
```

Si on veut pouvoir modifier la valeur des éléments du vecteur, il suffit
d'utiliser une référence :
```{R echo = FALSE, results = "asis"}
include.cpp('addOne.cpp')
```

```{r prompt = TRUE, comment = NA}
a <- 1:10
addOne(a)
a
```

**NOTE** En utilisant une référence, on évite la copie. Même si on ne désire pas modifier les éléments
du vecteur, cela peut modifier énormément les performances de la boucle en question ! 

**TODO ajouter exemple !!!**

### Nombres spéciaux

C++11 propose aussi des fonctions pour tester si des nombres flottants sont
finis ou non, sont `NaN`. Il est aussi plus facile de renvoyer un `NaN` ou une
valeur infinie (c'était possible avec `std::numeric_limits`).

```{R echo = FALSE, results = "asis"}
include.cpp('tests.cpp')
```

```{R echo = FALSE, results = "asis"}
include.cpp('specials.cpp')
```

```{r prompt = TRUE, comment = NA}
tests( NA )
tests( -Inf )
tests( pi )
specials();
```