prerequisite.qmd

# Prérequis

## Installation de R et RStudio

R et RStudio sont deux logiciels en libre accès sur internet. Le logiciel R peut être utilisé indépendamment du logiciel RStudio. En revanche, l’utilisation du logiciel RStudio requiert au préalable l’installation du logiciel R. En effet, RStudio est un logiciel qui permet d’utiliser les fonctionnalités de R tout en proposant une interface d’utilisation plus agréable et fonctionnelle que l’interface à l’origine proposée pour le logiciel R, qui est très basique. Les explications présentées au cours de ce document considèrent que l'utilisateur fonctionne avec RStudio.

### Installer R sur WINDOWS

* Aller sur le site https://cran.rstudio.com.
* Sur la page web qui s’affiche, l’encart du haut **Download and Install R** montre les différents liens de téléchargement possibles selon le système d’exploitation utilisé. Cliquer sur le lien **Download R for Windows**.
* Dans la nouvelle fenêtre qui vient de s’ouvrir, cliquer sur **install R for the first time**.
* Dans la nouvelle fenêtre qui vient de s’ouvrir, cliquer sur le premier lien en haut de la page : **Download R-X.X.X. for Windows**. Exécuter le fichier s'il est proposé de le faire. Si ce n’est pas le cas, il est probable que le téléchargement du fichier ait été lancé automatiquement. Retrouver le fichier ainsi téléchargé sur le PC (une fois son enregistrement terminé), puis exécuter le fichier. 
* Suivre la procédure d’installation par défaut en cliquant à chaque fois sur **Suivant**.
* Une fois l’installation terminée, double-cliquer sur l’icône du bureau (**R x64 X.X.X**) pour vérifier que l’ouverture du logiciel R s’effectue correctement.

### Installer R sur MAC

* Aller sur le site https://cran.rstudio.com.
* Sur la page web qui s’affiche, l’encart du haut **Download and Install R** montre les différents liens de téléchargement possibles selon le système d’exploitation utilisé. Cliquer sur le lien **Download R for macOS**.
* Dans la nouvelle fenêtre qui s’ouvre, cliquer sur le lien qui correspond à votre version OS (le clic entraînera le début du téléchargement du fichier).
* Sur le Mac, chercher dans le dossier **Téléchargements** le fichier  téléchargé.
* Double-cliquer sur le fichier téléchargé pour lancer l’installation du logiciel R.
* Suivre la procédure par défaut et terminer l’installation.
* Lorsque l'installation est terminée, aller dans le dossier **Applications** du Mac pour rechercher le logiciel R. Double-cliquer sur l’icône pour ouvrir le logiciel et vérifier que l’ouverture se déroule correctement.

### Installer RStudio sur WINDOWS ou MAC

* Aller sur le site https://posit.co/.
* En haut à droite de la page d’accueil, cliquer sur le bouton **DOWNLOAD RSTUDIO**.
* Dans la nouvelle fenêtre qui vient de s’ouvrir, faire défiler la page vers le bas jusqu’à aller dans la section RStudio Desktop puis cliquer sur le bouton **DOWNLOAD RSTUDIO**.
* Dans la nouvelle fenêtre qui vient de s’ouvrir, cliquer sur le bouton **DOWNLOAD RSTUDIO DESKTOP FOR WINDOWS** si vous avez une machine Windows. Si vous avez un MAC et que le bouton n'est pas mis à jour automatiquement pour votre MAC, alors il faut faire défiler un peu la page vers le bas pour ensuite cliquer sur le lien de téléchargement de RStudio adapté à votre version de système d'exploitation.
* **Sur WINDOWS :** Exécuter le fichier s'il est proposé de le faire. Si le clic entraîne automatiquement le téléchargement du fichier, retrouver alors ce fichier sur le PC (une fois son enregistrement terminé), puis exécuter le fichier et suivre la procédure d’installation par défaut. Une fois le logiciel installé, retrouver le fichier d’exécution du logiciel sur le PC (chemin d'accès possible : **Ordinateur > Windows (C:) > Programmes > RStudio > bin > rstudio.exe**). Créer un raccourci pour le fichier **rstudio.exe** (clic droit sur le fichier > Créer un raccourci) et mettre le raccourci sur le bureau du PC. Double-cliquer sur l’icône RStudio afin de vérifier si l’ouverture s’effectue correctement. 
* **Sur MAC :** Le téléchargement débute lorsque vous cliquez sur le lien. Une fois le téléchargement terminé, sur votre MAC, réaliser l’installation en double-cliquant sur le fichier téléchargé et en suivant la procédure indiquée. Une fois l’installation terminée, aller dans le dossier **Applications** du MAC et double-cliquer sur l’icône de RStudio pour vérifier si le logiciel s’ouvre correctement. 

## Prise en main de RStudio

### Fonctionnement général

Basiquement, RStudio s'utilise de la manière suivante : on écrit une instruction (i.e., une ligne de code) dans une fenêtre, on lance cette instruction, et le logiciel nous donne le résultat, qu'il s'agisse d'un calcul, d'un graphique, d'une modification d'un jeu de données, etc. Quand on ouvre RStudio pour la première fois, la fenêtre principale qui se présente est la **Console**. Cette fenêtre permet d'y écrire des lignes de code et de les lancer en appuyant sur la touche **Entrée**. Lorsque l'on souhaite conserver les lignes de code que l'on a écrites, ou que l'on souhaite écrire des lignes de code sans forcément les lancer, il est possible d'utiliser une fenêtre **Script** (chemin d'accès : **File > New File > R Script**). Pour lancer les lignes de code qui sont écrites dans une fenêtre de script, il suffit  de se placer n'importe où sur la ligne de code et de cliquer sur l'icône **Run** du logiciel (raccourci : **Ctrl + Entrée**). Une fois le code activé, celui-ci est montré dans la Console, et selon la nature de la commande, le résultat peut apparaître lui aussi dans la Console ou dans l'un des encarts disposés par défaut à droite de l'écran, selon qu'il s'agisse notamment d'un nouvel objet (e.g., une variable), d'une demande d'aide, ou de la création d'un graphique.

### Manipuler des objets (valeurs, vecteurs, et tableaux de données)

R permet tout d'abord d'effectuer des opérations simples avec des nombres, telles que des additions avec le symbole `+`, des soustractions avec le symbole `-`, des multiplications avec le symbole `*`, des divisions avec le symbole `/`, des racines carrées avec la fonction `sqrt()`, ou encore des élévations à la puissance avec le symbole `^`.

```{r simple_operations}
(9 + 3 - 5) * 5 / 2 + sqrt(9) ^ 2
```

De manière plus élaborée, R permet aussi de créer des vecteurs (i.e., des suites de valeurs), notamment grâce à la fonction `c()`, et de les manipuler avec différentes sortes d'opérations. Lorsqu'une opération ou une série d'opérations est appliquée à un vecteur, chaque valeur du vecteur subit les opérations spécifiées. Dans l'exemple ci-dessous, on voit par exemple que chaque valeur du vecteur a été multipliée par 2 et s'est vue ajouter la valeur 3.

```{r numerical_vectors}
c(0, 1, 2, 3, 4, 5) * 2 + 3
```

Si des vecteurs peuvent contenir des nombres, ils peuvent également contenir des caractères, tels que de simples lettres ou des mots, ces vecteurs ne pouvant cependant pas, par nature, subir des opérations mathématiques. Pour pouvoir être crées, les caractères doivent être écrits à l'intérieur du vecteur avec des guillemets (`" "`).

```{r character_vectors}
c("a", "b", "c")
c("Pierre", "Marie", "Jean")
```

De manière encore plus élaborée, R permet de créer des tableaux de données à partir de vecteurs à l'aide de la fonction `data.frame()`. Dans l'exemple ci-dessous, les noms x, y, et z, marqués à gauche du signe `=`, sont les noms des vecteurs que contiendra le tableau de données. À droite du signe `=`, on retrouve la fonction `c()` qui permet de créer un vecteur avec des valeurs à l'intérieur.

```{r data_frame}
data.frame(
  x = c(0, 1, 2, 3),
  y = c(3, 5, 7, 9),
  z = c("a", "b", "c", "d")
)
```

### Manipuler des objets via des noms

L'une des particularités de R, c'est de permettre d'associer des objets (e.g., des valeurs, des vecteurs, ou encore des tableaux de données) à des noms. Pour ce faire, R utilise la fonction d'assignation `<-`. Cette fonction s'utilise en écrivant à droite de la flèche l'objet à créer (ou qui est déjà crée), et en écrivant à gauche de la flèche le nom auquel on veut que l'objet soit associé (Attention : Toujours utiliser seulement des caractères alphanumériques et des points `.` ou des tirets du bas `_` pour écrire un nom ; ne pas commencer par un chiffre ; avoir à l'esprit que R est sensible à la casse, ce qui veut dire qu'un nom commençant par une majuscule sera un nom différent de celui qui a les mêmes lettres mais qui commence par une minuscule.) L'utilisation de noms associés à des objets permet de grandement faciliter les analyses par la suite. Lorsqu'on réalise une assignation, il est possible de voir le nouveau nom et l'objet associé dans la fenêtre **Environnement** de RStudio. Lorsqu'on lance le code permettant d'assigner un objet à un nom, R ne montre pas le contenu de l'objet. Pour le voir, il faut écrire le nom associé à l'objet dans une ligne de code et lancer la commande.

Il est donc possible d'associer à un nom un objet qui serait une valeur numérique...

```{r numerical_value_object}
a <- 9
a
```

... ou encore une succession de caractères ...

```{r character value object}
Prenom <- "Pierre"
Prenom
```

... ou encore un vecteur ...

```{r vector_object}
Taille <- c(178, 191, 178, 182, 167, 151)
Taille
Poids <- c(60, 89, 92, 67, 80, 70)
Poids
Sexe <- c("M", "M", "F", "F", "M", "F")
Sexe
```

... et même un tableau de données, qui aurait été soit conçu à la main, soit conçu à partir d'objets de type vecteurs qui auraient été crées auparavant, comme ci-dessous. À noter que les vecteurs doivent contenir le même nombre de valeurs pour pouvoir être combinés dans un tableau de données avec la fonction `data.frame()`.

```{r data_frame_object}
df <- data.frame(Taille, Poids, Sexe)
df
```

Lorsqu'un objet de type tableau de données est assigné à un nom, il est possible d'afficher le contenu d'une seule colonne de ce tableau à partir du nom associé au tableau, du symbole `$`, et du titre de la colonne désirée.

```{r column_object}
df$Taille
```

Une fois que des objets sont liés à des noms, il est possible, comme montré initialement avec des valeurs, d'utiliser ces noms pour réaliser des opérations. Par exemple, via des noms, on peut manipuler des objets contenant simplement une valeur numérique...

```{r calculations_objects}
a <- 7
b <- 3
c <- 2
(a + b) / c
```

ou alors des objets contenant un vecteur ...

```{r calculations_with_vector_objects}
vec1 <- c(0, 2, 4, 6, 8)
vec2 <- c(1, 4, 5, 9, 0)
vec1 * 10
vec1 * vec2
```

ou encore des objets contenant un tableau de données, en créant par exemple une variable à partir d'autres variables du tableau.

```{r calculations_with_data_frame_objects}
df$IMC <- df$Poids / (df$Taille / 100) ^ 2
df
```

Lorsque plusieurs objets ont été assignés à des noms, il est possible de vouloir supprimer certaines assignations, par exemple en raison du fait qu'un objet aurait été assigné par erreur. Pour supprimer une assignation, il est possible d'utiliser la fonction `rm()`.

```{r objects_deletion}
rm(vec1)
```

L'instruction `rm(list = ls())` supprime toutes les assignations qui ont été réalisées auparavant.
 
### Utiliser des fonctions

Dans les exemples de code précédents, nous avons utilisé plusieurs fonctions : la fonction `sqrt()`, la fonction `c()`, la fonction `data.frame()`, et la fonction `rm()`. Par la suite, nous serons amenés à voir comment l'on crée une fonction et comment l'on arrive finalement à n'avoir qu'une expression suivie de parenthèses à utiliser pour faire un ensemble d'actions automatiquement. Mais avant cela, il est important de savoir globalement comment une fonction s'utilise. Cela est important car il est rapidement possible de se rendre compte qu'utiliser R, c'est utiliser des fonctions. De plus, lorsque l'on souhaite réaliser une nouvelle analyse avec une fonction que l'on n'a jamais utilisée auparavant, il est nécessaire de pouvoir en comprendre la structure et d'être en mesure d'en comprendre le fonctionnement pour pouvoir l'utiliser.

Pour expliquer comment s'utilise une fonction, commençons directement par un exemple, cette fois avec la fonction `plot()` :

```{r plot_function1}
#| eval: false

plot(x = iris$Sepal.Length, y = iris$Petal.Length)
```

Comme nous pouvons l'observer ci-dessus, pour utiliser une fonction, il faut d'abord écrire son nom, puis mettre des parenthèses pour qu'on puisse écrire des informations à l'intérieur. Ces informations, elles sont de deux natures. D'un côté il y a les **arguments** (qui sont `x` et `y` dans l'exemple ci-dessus), et d'un autre côté il y a les **valeurs** (qui sont les variables `Sepal.Length` et `Petal.Length` du jeu de données `iris` dans l'exemple ci-dessus). Notons ici que le concept de valeur est à prendre au sens général du terme. Dans ce cadre là, une valeur pourrait tout aussi bien désigner des nombres ou des lettres, des vecteurs, des jeux de données, etc. Avec certaines fonctions, nous aurions pu mettre le nom de la variable seul et mettre le nom du jeu de données en face d'un autre argument, mais cela n'était pas possible ici. Comme nous pouvons le voir également, l'argument et la valeur sont toujours mis en lien par le biais du signe `=`. (Attention : Nous verrons plus tard qu'avec certaines fonctions, l'écriture qui est à gauche du signe `=` est en fait le nom d'une nouvelle variable à créer, mais laissons cela de côté pour le moment.)
Le nombre d'arguments dépend des fonctions. Certaines n'en n'ont qu'un, d'autres peuvent en avoir un très grand nombre. Dans une fonction, certains arguments doivent obligatoirement recevoir une valeur indiquée par nos soins, alors que d'autres arguments ne seront tout simplement pas utilisés si on ne leur associe pas une valeur particulière. Enfin, certains arguments prendront une valeur par défaut associée à la fonction si l'on écrit rien les concernant dans la fonction. Dans la fonction `plot()`, seul l'argument `x` doit obligatoirement recevoir une valeur pour que la fonction puisse être utilisée. Dans notre exemple, le fait d'avoir en plus associé une valeur à l'argument `y` permet à la fonction de non pas montrer uniquement les données de la variable `x`, mais de réaliser un graphique en montrant les données de `y` en fonction de `x`, comme illustré sur la @fig-plot_function2 : 

```{r plot_function2}
#| fig-align: "center"
#| fig-cap: "Graphique obtenu avec un paramétrage explicite de la fonction plot()"
#| out-width: '90%'
#| label: fig-plot_function2

plot(x = iris$Sepal.Length, y = iris$Petal.Length)
```

Lorsque les arguments sont explicitement précisés comme pour `x` et `y` de l'exemple ci-dessus, il est en réalité possible de les écrire dans l'ordre que l'on veut. Nous aurions par exemple très bien pu écrire les choses de la manière suivante sans que cela ne change rien au résultat de la commande :

```{r plot_function3}
#| eval: false

plot(y = iris$Petal.Length, x = iris$Sepal.Length)
```

Ce changement d'ordre n'est possible que lorsque les arguments sont explicitement précisés dans la fonction. Il est aussi possible de configurer une fonction en mettant des valeurs sans avoir à écrire les noms des arguments. Cependant, lorsque les noms des arguments ne sont pas précisés, R associe les valeurs (celles que l'on a mises) aux arguments de la fonction en suivant l'ordre par défaut des arguments avec lequel la fonction a été configurée. Ainsi, si nous voulons avoir, pour le graphique associé à notre exemple, la variable `Sepal.Length` en `x`, et la variable `Petal.Length` en `y`, on peut très bien écrire la fonction comme ceci :

```{r plot_function4}
#| eval: false

plot(iris$Sepal.Length, iris$Petal.Length)
```

En revanche, si nous avions inversé l'ordre d'écriture des variables dans la fonction sans préciser les noms des arguments (cf. code ci-dessous), nous aurions eu un résultat différent du graphique précédent (cf. @fig-plot_function5), où les variables en x et en y ont été inversées par rapport au graphique précédent).

```{r plot_function5}
#| fig-align: "center"
#| fig-cap: "Graphique obtenu avec un paramétrage implicite de la fonction plot()"
#| out-width: '90%'
#| label: fig-plot_function5

plot(iris$Petal.Length, iris$Sepal.Length)
```

Dans la suite de ce livre, les arguments configurés par nos soins seront en général précisés lorsque nous leur donnerons une valeur. Cela étant dit, beaucoup d'arguments seront aussi régulièrement laissés de côté lorsque cela ne sera pas nécessaire de les préciser pour l'exemple.

Au regard de ce qu'il vient d'être expliqué, il est donc une bonne pratique, avant d'utiliser une fonction, de connaître les arguments qu'elle contient, non seulement pour savoir comment configurer ses arguments, mais aussi pour savoir ce que font les arguments de la fonction lorsque l'on ne touche pas à leur configuration par défaut. En général, toute fonction utilisable et opérationnelle avec R dispose d'une aide  directement accessible via RStudio. Pour consulter l'aide associée à une fonction, il suffit d'écrire dans la Console le signe `?` suivi du nom de la fonction qui pose question, comme ci-dessous :

```{r help}
#| eval: false
?plot
```

Toutefois, paradoxalement, l'aide n'est pas toujours facile à comprendre pour ceux qui n'ont pas un niveau d'expertise avancé avec R. Pour bien comprendre comment on peut utiliser une fonction, internet peut être une excellente ressource car il regorge de sites et d'exemples crées par la communauté R. L'un des sites sur lesquels on tombe souvent lors d'une recherche internet est le site https://stackoverflow.com. Une bonne partie des problèmes de compréhension et d'utilisation des fonctions de R que l'on rencontre peuvent être résolus en consultant des exemples venant de ce site.

### Installer et charger des *packages*

R fonctionne en bonne partie sur la base de fonctions qui permettent de réaliser automatiquement différents types de calculs. Ces fonctions sont regroupées dans des ensembles qu'on appelle des *packages*. La version d'installation initialle du logiciel R dispose d'un ensemble de *packages* de base qui permettent de réaliser un très grand nombre d'analyses. Toutefois, la version de base de R impose parfois des manières d'écrire certaines instructions qui sont peu intuitives ou qui parfois ne permettent tout simplement pas de faire les analyses souhaitées. Pour palier ces problèmes, des *packages* sont régulièrement crées et actualisés par la communauté R. Pour pouvoir les utiliser, il est nécessaire de d'abord installer le *package* additionnel grâce à la fonction `install.packages()`. L'une des collections de *packages* les plus utiles pour manipuler des tableaux de données et effectuer des analyses statistiques et graphiques est celle du `{tidyverse}`, qui a été pensée notamment pour faciliter l'écriture des lignes de code.

```{r packages installation}
#| eval: false

install.packages("tidyverse")
```

Une fois que le *package* a été installé (ou l'ensemble de *packages* s'il s'agit d'une collection comme dans le cas du `{tidyverse}`), une étape supplémentaire est nécessaire pour pouvoir utiliser les fonctions qu'il contient : il faut le charger dans l'environnement R. Pour cela, il est possible d'utiliser la fonction `library()`.

```{r packages_loading}
#| message: false
#| warning: false

library(tidyverse)
```

Lorsque l'on charge la collection de *packages* `{tidyverse}`, on peut observer dans la Console que plusieurs *packages* sont chargés en même temps : `{ggplot2}`, pour la visualisation de données ; `{dplyr}`, pour la manipulation de données ; `{tidyr}`, pour l'organisation des tableaux de données ; `{readr}`, pour l'importation de jeux de données ; `{purrr}`, pour l'automatisation ; `{tibble}`, pour le formatage de tableaux de données ; `{stringr}`, pour la gestion des chaînes de caractères ; `{forcats}`, pour la gestion de variables qualitatives. Si nous avons téléchargé et chargé l'ensemble des *packages* du `{tidyverse}`, nous aurions pu aussi installé et chargé un seul de ces *packages* à la fois, comme pour la plupart des *packages* qui existent.

### Divers

Au fur et à mesure que l'on écrit un script, une bonne pratique consiste à régulièrement créer des sections avec des titres et d'ajouter des commentaires pour certaines analyses. Afin de ne pas rendre activable les lignes de code qui ne serviraient qu'à écrire des titres ou des commentaires, il convient d'utiliser le symbole `#` devant l'écriture du code.

```{r comments}
# Titre de section 1 -------------------------------------------
## Sous-titre 1
## Sous-titre 2
```

Étant donné que l'erreur est difficile à éviter à un moment donné ou à un autre lorsqu'on commence à écrire son propre code ou à utiliser un code qui vient de quelqu'un d'autre, il est utile de reconnaître les situations dans lesquelles une erreur est survenue. La situation la plus évidente est l'apparition d'un texte en rouge dans la Console. Lorsqu'il s'agit bel et bien d'une erreur (car il peut ne s'agir parfois que d'un message d'alerte ou d'information), le texte en rouge décrit l'erreur qui a été détectée et qui empêche le code d'être entièrement activé. De manière moins visible, il est possible parfois d'observer un `+` tout en bas de la Console. Cela survient lorsque le code lancé à l'instant est incomplet (e.g., une parenthèse a été oubliée). Si cela arrive, il vaut mieux  appuyer sur **Echap**, trouver l'erreur dans le code, et relancer la commande. Avant de relancer la commande, il faut s'assurer que R  donne effectivement la main pour lancer une nouvelle instruction. C'est le cas lorsque le symbole `>` est observé dans la Console. Enfin, RStudio permet d'utiliser un certain nombre de raccourcis clavier. Pour en avoir une vue d'ensemble, appuyez sur **Alt+Shift+K**.

## Résumé

* R permet de faire des opérations sur des valeurs : additions, soustractions, multiplications, divisions, etc.
* R permet de faire des opérations sur des objets : valeurs uniques, vecteurs, tableaux de données, etc.
* Pour créer un vecteur, qu'il contienne des nombres, du texte, ou les deux, il est possible d'utiliser la fonction `c()`.
* Pour créer un tableau de données, il est possible d'utiliser la fonction `data.frame()`.
* Pour afficher une colonne particulière d'un tableau de données, utiliser le symbole `$`.
* Pour associer un objet à un nom, utiliser la fonction d'assignation `<-`.
* Pour supprimer une assignation, utiliser la fonction `rm()`.
* L'utilisation de R repose sur l'utilisation de fonctions. Une fonction s'utilise en écrivant son nom, suivi de parenthèses à l'intérieur desquelles on peut préciser les arguments qui nous intéressent et indiquer les valeurs nécessaires selon les besoins des analyses.
* Pour demander l'aide de R à propos d'une fonction, écrire `?` suivi du nom de la fonction.
* Pour installer un *package*, utiliser la fonction `install.packages()`.
* Un code peut être écrit directement dans la **Console**, ou dans une fenêtre **Script**. Pour activer le code à partir d'un script, utiliser le bouton **Run** ou **Ctrl + Entrée**. 
* Les noms et les objets associés apparaissent dans la fenêtre **Environnement**.
* Pour écrire des titres et des commentaires dans un script, utiliser un ou plusieurs `#` avant l'écriture du code.
* Dans la Console, le symbole `>` signifie que le logiciel est prêt à lancer une nouvelle instruction. Le symbole `+` indique que l'instruction initialement lancée est incomplète. Mieux vaut alors faire **Echap**, modifier le code, et recommencer.