17-if-boucles.qmd

# Exécution conditionnelle et boucles

{{< include _setup.qmd >}}

Nous avons vu précédemment comment écrire nos propres fonctions. Cette section présente des éléments du langage qui permettent de programmer des actions un peu plus complexes : exécuter du code de manière conditionnelle selon le résultat d'un test, et répéter des opérations avec des boucles.

Les notions décrites dans cette partie s'appliquent pour le développement de fonctions, mais peuvent aussi être mises en œuvre à tout moment dans un script.

On commence par charger les jeux de données d'exemple utilisés par la suite :

```{r}
library(questionr)
data(hdv2003)
data(rp2018)
```


## `if` et `else` : exécuter du code sous certaines conditions

### `if`

L'instruction `if` permet de n'exécuter du code que si une condition est remplie.

`if` est suivie d'une condition (entre parenthèses) puis d'un bloc de code (entre accolades). Ce bloc de code n'est exécuté que si la condition est vraie.

![](resources/figures/structure_if)

Par exemple, dans le code suivant, le message `Bonjour !` ne sera affiché que si la valeur de l'objet `prenom` vaut `"Pierre-Edmond"` :

```{r}
prenom <- "Pierre-Edmond"
if (prenom == "Pierre-Edmond") {
    message("Bonjour !")
}
```

On peut utiliser ce code pour créer une passionnante fonction qui a pour objectif de ne dire bonjour qu'aux personnes qui s'appellent Pierre-Edmond :

```{r}
bonjour_pierre_edmond <- function(prenom) {
    if (prenom == "Pierre-Edmond") {
        message("Bonjour !")
    }
}

bonjour_pierre_edmond("Pierre-Edmond")

bonjour_pierre_edmond("Valérie-Charlotte")
```

Une autre utilisation possible (et un peu plus utile) dans le cadre d'une fonction est de n'exécuter certaines instructions que si la valeur d'un argument vaut une valeur donnée. Dans l'exemple suivant, on n'applique la fonction `round()` que si l'argument `arrondir` vaut `TRUE`.

```{r}
moyenne <- function(x, arrondir = TRUE) {
    res <- mean(x)
    if (arrondir == TRUE) {
        res <- round(res)
    }
    res
}

v <- c(1.4, 2.3, 8.9)
moyenne(v)
moyenne(v, arrondir = FALSE)
```

::: {.callout-warning}
On notera que le test `x == TRUE` est en fait redondant, car son résultat est le même que la valeur de `x` :

- si `x` vaut `TRUE`, `x == TRUE` vaut `TRUE`
- si `x` vaut `FALSE`, `x == TRUE` vaut `FALSE`

On remplacera donc en général `if (x == TRUE)` par `if (x)`.

De la même manière, on pourra remplacer `if (x == FALSE)` par `if (!x)`.
:::

Dans notre fonction `moyenne` ci-dessus, on peut donc remplacer :

```{r eval=FALSE}
if (arrondir == TRUE) {
    res <- round(res)
}
```

Par :

```{r eval=FALSE}
if (arrondir) {
    res <- round(res)
}
```



À noter également que quand le bloc de code qui suit une instruction `if` ne comporte qu'une seule instruction, on peut omettre les accolades qui l'entourent. Les syntaxe suivantes sont donc équivalentes :

```{r eval=FALSE}
if (arrondir) {
    res <- round(res)
}

if (arrondir) res <- round(res)
```



### `if` / `else`

On utilise souvent `if` en le faisant suivre par une instruction `else`. `else` précède un autre bloc de code R qui ne s'exécute que si la condition donnée au `if` est fausse :

![](resources/figures/structure_if_else)

On peut ainsi utiliser `if` / `else` pour une nouvelle fonction fort utile qui nous évitera bien des désagréments météorologiques.

```{r}
conseil_vestimentaire <- function(temperature) {
    if (temperature > 15) {
        message("La polaire n'est pas forcément nécessaire.")
    } else {
        message("Vous devriez prendre une petite laine.")
    }
}

conseil_vestimentaire(-5)
```

Plus utile, on peut l'utiliser pour effectuer deux actions différentes en fonction de la valeur d'un argument. La fonction suivante génère deux graphiques différents selon le type du vecteur passé en argument :

```{r}
graph_var <- function(x) {
    if (is.character(x)) {
        barplot(table(x))
    } else {
        hist(x)
    }
}

graph_var(c("Pomme", "Pomme", "Citron"))
graph_var(c(1, 5, 10, 3, 1, 4))
```



### "`if`" / "`else if`" / "`else`"

Une possibilité complémentaire est d'ajouter des blocs `else if` qui permettent d'ajouter des conditions supplémentaires. Dès qu'une condition est vraie, le bloc de code correspondant est exécuté. Le dernier bloc `else` est exécuté si aucune des conditions n'est vraie.

On peut donc améliorer encore notre fonction `graph_var()` pour tester plusieurs types explicitement et afficher un message si aucun type géré n'a été reconnu.

```{r}
graph_var <- function(x) {
    if (is.character(x)) {
        barplot(table(x))
    } else if (is.numeric(x)) {
        hist(x)
    } else {
        message("Le type de x n'est pas géré par la fonction")
    }
}

graph_var(c(TRUE, FALSE, TRUE))
```

Attention, seul le bloc de la première condition vraie est exécuté, l'ordre des conditions est donc important. Dans l'exemple suivant, le second bloc n'est jamais exécuté et donc le second message jamais affiché.

```{r}
test_x <- function(x) {
    if (x < 100) {
        message("x est inférieur à 100")
    } else if (x < 10) {
        message("x est inférieur à 10")
    }
}

test_x(5)
```

Il est donc important d'ordonner les conditions de la plus spécifique à la plus générale.

### Construction de conditions complexes

On peut combiner plusieurs tests avec les opérateurs logiques classiques :

- `&&` est l'opérateur "et", qui est vrai si les deux conditions qu'il réunit sont vraies
- `||` est l'opérateur "ou", qui est vrai si au moins l'une des deux conditions qu'il réunit sont vraies
- `!` est l'opérateur "not", qui teste si la condition qu'il précède est fausse

Ainsi, si on veut qu'une variable `temperature` soit comprise entre 15 et 25, on écrira :

```{r eval = FALSE}
verifie_temperature <- function(temperature) {
    if (temperature >= 15 && temperature <= 25) {
        message("Température ok")
    }
}
verifie_temperature(20)
```

Si on souhaite tester que `temperature` est inférieure à 15 ou supérieure à 25 :

```{r eval = FALSE}
verifie_temperature <- function(temperature) {
    if (temperature < 15 || temperature > 25) {
        message("Température pas glop")
    }
}
verifie_temperature(10)
```

Si on veut tester si `temperature` vaut `NULL`, on peut utiliser `is.null()`.

```{r eval = FALSE}
verifie_temperature <- function(temperature = NULL) {
    if (is.null(temperature)) {
        message("Merci d'indiquer une température")
    }
}
verifie_temperature()
```

Mais si à l'inverse on veut tester si `temperature` *n'est pas* `NULL`, on inverse le test précédent en utilisant `!`.

```{r eval = FALSE}
verifie_temperature <- function(temperature = NULL) {
    if (!is.null(temperature)) {
        message("Merci d'avoir indiqué une température")
    }
}
verifie_temperature(15)
```

On pourra noter qu'il existe deux types d'opérateurs "et" et "ou" dans R :

- Les opérateurs simples `&` et `|` sont des opérateurs *vectorisés*. Ils peuvent s'appliquer à des vecteurs et retourneront un vecteur de `TRUE` et `FALSE`.
- Les opérateurs doubles `&&` et `||` ne peuvent retourner qu'une seule valeur, et si on leur fournit des vecteurs ils génèrent une erreur.

```{r}
x <- 1:5
x > 0 & x <= 2
```

```{r error=TRUE}
x > 0 && x <= 2
```

Quand on passe un test à un `if`, celui-ci est censé retourner une unique valeur `TRUE` ou `FALSE`. Une erreur fréquente, notamment quand on est dans une fonction, est de passer à `if` une condition appliquée à un vecteur. Dans ce cas R a la bonne idée d'afficher une erreur^[Pour les versions de R antérieures à la 4.2, seul un avertissement est affiché et R n'utilise alors que la première valeur du vecteur pour déterminer si le bloc de code doit être exécuté ou non.].

```{r error=TRUE}
superieur_a_5 <- function(x) {
    if (x >= 5) {
        message(">=5")
    }
}

superieur_a_5(1:10)
```

::: {.callout-warning}
À retenir : quand on utilise l'instruction `if`, la condition qui lui est passée entre parenthèses ne doit renvoyer qu'une seule valeur `TRUE` ou `FALSE`. Si on utilise une condition complexe, on utilisera donc plutôt les opérateurs doubles `&&` et `||`.
:::


### Différence entre `if` / `else` et `ifelse`

Une source fréquente de confusion concerne la différence entre les instructions `if` / `else` et la fonction `ifelse()` de R base (ou son équivalent `if_else()` de `dplyr`, voir @sec-if-else). Les deux sont pourtant très différentes :

- `if` / `else` s'utilisent quand on teste une seule condition et qu'on veut exécuter des blocs de code différents selon son résultat
- `ifelse` applique un test à tous les éléments d'un vecteur et retournent un vecteur dont les éléments dépendent du résultat de chaque test

Premier cas de figure : un objet `x` contient une seule valeur et on veut afficher un message différent selon si celle-ci est inférieure ou supérieure à 10. Dans ce cas on utilise `if` / `else`.

```{r}
x <- 5

if (x >= 10) {
    message(">=10")
} else {
    message("<10")
}
```

Deuxième cas de figure : `x` est un vecteur et on souhaite recoder chacune de ses valeurs selon le même critère que ci-dessus. Dans ce cas on utilise `ifelse`.

```{r}
x <- 5:15
x_rec <- ifelse(x >= 10, ">=10", "<10")
x_rec
```



## Contrôle de l'exécution et gestion des erreurs

L'instruction `if` est souvent utilisée dans des fonctions pour valider les valeurs passées en arguments, ou plus généralement pour contrôler que l'exécution du code se déroule comme prévu.

### Utilisation de `return` pour sortir de la fonction

On peut utiliser un `return` pour interrompre l'exécution de la fonction et retourner un résultat. On a en effet vu @sec-resfunc que dès que R rencontre un `return` dans une fonction, il interrompt immédiatement l'exécution de celle-ci.

La fonction suivante retourne la longueur du mot le plus long dans un vecteur de chaînes de caractères.

```{r}
longueur_max <- function(x) {
    max(nchar(x))
}

longueur_max(c("Pomme", "Pamplemousse"))
```

Cette fonction n'a pas trop de sens si on lui passe en entrée un vecteur qui n'est pas un vecteur de chaînes de caractères. On peut donc rajouter un test qui, si `x` n'est pas de type `character`, retourne directement la valeur `NA`.

```{r}
longueur_max <- function(x) {
    if (!is.character(x)) {
        return(NA)
    }
    max(nchar(x))
}

longueur_max(1:5)
```


### `warning`

La fonction `warning` fonctionne comme `message` mais permet d'afficher un avertissement. Celui-ci est présenté un peu différemment dans la console de manière à attirer l'attention, et il indique quelle fonction a déclenché l'avertissement, ce qui peut être utile pour retrouver l'origine du problème.

Dans la fonction précédente, on peut ajouter un avertissement dans le cas où le vecteur passé en argument n'est pas de type `character`.

```{r}
longueur_max <- function(x) {
    if (!is.character(x)) {
        warning("x n'est pas de type character, le résultat vaut NA.")
        return(NA)
    }
    max(nchar(x))
}

longueur_max(1:5)
```

### `stop` et `stopifnot`

`stop` fonctionne comme `warning` mais déclenche une erreur qui interrompt totalement l'exécution du code. Quand R le rencontre dans une fonction, il sort immédiatement de la fonction, ne retourne aucun résultat, et il interrompt également toutes les autres instructions en attente d'exécution.

On peut ainsi considérer, toujours dans la fonction `longueur_max`, que le fait de ne pas fournir en argument un vecteur de type `character` est suffisamment "grave" pour interrompre l'exécution en cours et forcer la personne qui utilise la fonction à régler le problème.

```{r error = TRUE}
longueur_max <- function(x) {
    if (!is.character(x)) {
        stop("x doit être de type character.")
    }
    max(nchar(x))
}

longueur_max(1:5)
```

::: {.callout-note}
Savoir si un problème doit être traité comme un avertissement ou comme une erreur relève du choix de la personne qui développe la fonction : chaque cas est particulier.
:::

`stopifnot` est une syntaxe alternative plus compacte qui combine test et message d'erreur. On lui passe en premier argument une condition, et en deuxième argument un message à afficher si la condition est fausse.

On peut donc réécrire notre fonction `longueur_max` ci-dessus de la manière suivante :

```{r error = TRUE}
longueur_max <- function(x) {
    stopifnot(is.character(x))
    max(nchar(x))
}

longueur_max(1:5)
```

Si on souhaite un message d'erreur personnalisé il faut le passer comme nom de la condition.

```{r error = TRUE}
longueur_max <- function(x) {
    stopifnot(
        "x doit être de type character" = is.character(x)
    )
    max(nchar(x))
}

longueur_max(1:5)
```


### Tester la présence d'un argument facultatif {#sec-test-arg}

On a vu @sec-arg-oblig que pour rendre un argument de fonction "facultatif", on doit lui attribuer une valeur par défaut. Parfois cependant, on n'a pas de valeur par défaut évidente à lui attribuer directement : dans ce cas on lui attribue la valeur `NULL` et on utilise un `if()` dans la fonction pour déterminer s'il a été défini ou non par l'utilisateur.

Par exemple, soit une fonction qui génère un graphique avec un argument `titre` qui permet de définir son titre.

```{r}
histo <- function(x, titre) {
    hist(x, main = titre)
}
```

Si l'utilisateur ne donne pas de titre, on souhaite ajouter un titre qui indique la valeur de la moyenne de la variable représentée. Dans ce cas on attribue à `titre` la valeur par défaut `NULL`, et on vérifie dans le corps de la fonction que l'utilisateur n'a pas fourni de valeur avec `if (is.null(titre))`. On peut alors calculer la valeur "par défaut" souhaitée :

```{r}
histo <- function(x, titre = NULL) {
    if (is.null(titre)) {
        titre <- paste("Moyenne :", mean(x))
    }
    hist(x, main = titre)
}
```

```{r}
x <- c(1, 15, 8, 10, 12, 18, 8, 4)
histo(x)
```

```{r}
histo(x, titre = "Quel bel histogramme")
```




## `for` et `while` : répéter des instructions dans une boucle

Les boucles permettent de répéter du code plusieurs fois, soit en fonction d'une condition soit selon les éléments d'un vecteur^[En complément, on verra également @sec-purrr d'autres fonctions tirées de l'extension `purrr` qui permettent d'appliquer une fonction en itérant sur les éléments de plusieurs objets.].

### `for`

Le premier type de boucle est défini par l'instruction `for`. Sa structure est la suivante :

![](resources/figures/structure_for)

Le principe est le suivant : on fournit à `for` entre parenthèses une expression du type `item in vecteur`, puis un bloc de code entre accolades. `for` va exécuter le bloc de codes pour chacune des valeurs de `vecteur`, et affectera tour à tour à `item` la valeur courante de `vecteur`.

Prenons tout de suite un exemple pour mieux comprendre.

```{r}
for (item in 1:5) {
    print(item)
}
```

Ici notre vecteur "source" est constitué des entiers de 1 à 5. `for` va donc exécuter l'instruction `print(item)` 5 fois, en remplaçant la première fois `item` par 1, la seconde fois par 2, etc.

On peut itérer sur différents types d'objets, et le nom `item` peut être remplacé par ce que l'on souhaite :

```{r}
for (prenom in c("Pierre-Edmond", "Valérie-Charlotte")) {
    message("Bonjour ", prenom, " !")
}
```

Exemple un peu plus complexe, la fonction suivante prend en entrée un tableau de données et un vecteur de noms de variables, et affiche le résultat de `summary` pour chacune de ces variables.

```{r}
summaries <- function(d, vars) {
    for (var in vars) {
        message("--- ", var, " ---")
        print(summary(d[, var]))
    }
}

summaries(hdv2003, c("sexe", "age", "heures.tv"))
```

Parfois on souhaite itérer sur les éléments par leur position plutôt que par leur valeur. Dans l'exemple suivant, la fonction `affiche_dimensions` affiche le nombre de lignes et de colonnes des tableaux de données contenus dans une liste :

```{r}
affiche_dimensions <- function(dfs) {
    for (df in dfs) {
        message("Dimensions : ", nrow(df), "x", ncol(df))
    }
}

l <- list(
    hdv = hdv2003,
    rp = rp2018
)

affiche_dimensions(l)
```

Si on souhaite afficher le nom du tableau en plus de ses dimensions afin de rendre les résultats plus lisibles, on doit itérer sur la position des éléments pour pouvoir récupérer à la fois leur nom (dans `names(dfs)`) et leur valeur (dans `dfs`). Dans ces cas-là on peut utiliser la fonction `seq_along()` qui génère une liste d'entiers correspondant au nombre d'éléments de l'objet qu'on lui passe en argument.

```{r}
x <- c("rouge", "vert", "bleu")
seq_along(x)
```

On peut du coup réécrire `affiche_dimensions` de la façon suivante.

```{r}
affiche_dimensions <- function(dfs) {
    for (i in seq_along(dfs)) {
        name <- names(dfs)[[i]]
        df <- dfs[[i]]
        message("Dimensions de ", name, " : ", nrow(df), "x", ncol(df))
    }
}

affiche_dimensions(l)
```

::: {.callout-note}
Il est assez naturel d'utiliser `for (i in 1:length(x))` plutôt que `for (i in seq_along(x))`. L'utilisation de `seq_along(x)` est cependant préférable, notamment lorsqu'on est dans une fonction, car elle n'essaie pas d'exécuter le bloc de code si jamais `x` est de longueur nulle.

En effet, si `length(x)` vaut 0 alors `1:length(x)` vaut `1:0`, c'est-à-dire le vecteur `c(1, 0)`, ce qui signifie que la boucle sera exécutée et risque de générer une erreur. De son côté, `seq_along(x)` garantit dans ces cas-là qu'aucune itération du `for` n'est exécutée.
:::

À noter que quand on sort d'une boucle `for`, l'objet utilisé pour itérer sur les valeurs du vecteur existe toujours, et contient la dernière valeur qu'il a prise.

```{r}
for (i in 1:3) {
    print("a")
}
print(i)
```

### `while`

`while` prend en argument une condition et est suivi d'un bloc de code entre accolades. Elle exécute le bloc tant que la condition est vraie :

![](resources/figures/structure_while)

Par exemple, la fonction suivante simule un tirage à pile ou face à l'aide de la fonction `sample()`. La simulation de tirage s'exécute et affiche le résultat tant qu'on obtient "Pile" (et interrompt la boucle au premier "Face") :

```{r eval = FALSE}
resultat <- ""
while (resultat != "Face") {
    resultat <- sample(c("Pile", "Face"), size = 1)
    print(resultat)
}
```

```
[1] "Pile"
[1] "Pile"
[1] "Face"
```

Le déroulement de la boucle est le suivant :

1. la première instruction initialise la valeur de la variable `resultat` avec une chaîne vide
2. à la première entrée dans le `while`, `resultat` vaut `""`, elle est donc différente de `"Face"` et le bloc de code est donc exécuté
3. à la fin de cette exécution, `resultat` vaut soit `"Pile"` soit `"Face"`. On entre alors une deuxième fois dans le `while`. Si `resultat` vaut `"Pile"`, la condition du `while` n'est pas vraie, on n'exécute donc pas le bloc de code et on sort de la boucle. Si `resultat` vaut `"Face"`, la condition est vraie, on exécute le bloc de code et on rentre ensuite une troisième fois dans le `while`, etc.


### `next` et `break`

Les instructions `next` et `break` permettent de modifier les itérations d'une boucle `for` ou `while`.

`next` permet de sortir de l'itération courante et de passer directement à l'itération suivante sans exécuter le reste du code.

Reprenons la fonction `summaries`, vue plus haut, qui affiche le résumé de plusieurs variables d'un tableau de données.

```{r}
summaries <- function(d, vars) {
    for (var in vars) {
        message("--- ", var, " ---")
        print(summary(d[, var]))
    }
}

summaries(hdv2003, c("sexe", "age"))
```

Si on passe à la fonction un nom de colonne qui n'existe pas, on obtient une erreur et les autres variables ne sont pas affichées.

```{r error=TRUE}
summaries(hdv2003, c("sexe", "igloo", "age"))
```

On pourrait dans ce cas vouloir afficher les résultats pour les "bonnes" colonnes, et ignorer les autres. C'est possible si on ajoute une instruction `next` quand la valeur courante de `var` ne fait pas partie des noms de colonnes (on pourrait aussi ajouter un `warning()` juste avant le `next` pour informer l'utilisateur).

```{r}
summaries <- function(d, vars) {
    for (var in vars) {
        if (!(var %in% names(d))) {
            next
        }
        message("--- ", var, " ---")
        print(summary(d[, var]))
    }
}

summaries(hdv2003, c("sexe", "igloo", "age"))
```

L'instruction `break` est un peu plus radicale : non seulement elle sort de l'itération courante sans exécuter la suite du code, mais elle interrompt carrément la boucle toute entière et n'exécute pas les itérations restantes.

Dans l'exemple précédent, si on remplace `next` par `break`, on voit bien qu'on sort de la boucle et que seule la première itération est totalement exécutée.

```{r}
summaries <- function(d, vars) {
    for (var in vars) {
        if (!(var %in% names(d))) {
            break
        }
        message("--- ", var, " ---")
        print(summary(d[, var]))
    }
}

summaries(hdv2003, c("sexe", "igloo", "age"))
```



### Quand (ne pas) utiliser des boucles {#sec-no-boucles}

Le mécanisme des boucles, assez intuitif, peut être utilisé pour beaucoup d'opérations. Il y a cependant sous R des alternatives souvent plus rapides, qu'il est préférable de privilégier.

Avant tout, de nombreuses fonctions R sont "vectorisées" et s'appliquent directement à tous les éléments d'un vecteur. Dans le cas où une fonction vectorisée existe déjà, elle propose en général une syntaxe plus compacte et une exécution (beaucoup) plus rapide.

Pour prendre un exemple caricatural, si on souhaite ajouter 10 à chaque élément d'un vecteur on évitera absolument de faire :

```{r, eval=FALSE}
for (i in seq_along(x)) {
    x[i] <- x[i] + 10
}
```

Et on se contentera d'un beaucoup plus simple `x + 10`.

Autre exemple, si on souhaite remplacer dans tous les éléments d'un vecteur de chaînes de caractères le caractère "X" par le caractère "o", on pourrait être tenter de faire une boucle du type :

```{r}
mots <- c("brXuette", "mXtX", "iglXX")
for (i in seq_along(mots)) {
    mots[i] <- str_replace_all(mots[i], "X", "o")
}
```

Or c'est tout à fait inutile car `str_replace_all()` étant vectorisée, on peut l'appliquer directement à un vecteur sans utiliser de boucle.

```{r}
mots <- str_replace_all(mots, "X", "o")
```

Dernier exemple, la boucle suivante remplace les valeurs manquantes d'un vecteur par les valeurs correspondantes d'un deuxième vecteur.

```{r}
x <- c(1, NA, 4, 110, NA)
y <- c(20, 30, 40, 50, 60)

for (i in seq_along(x)) {
    if (is.na(x[i])) {
        x[i] <- y[i]
    }
}
```

Cette boucle sera avantageusement remplacée par une utilisation plus compacte et plus rapide de l'opérateur `[]`.

```{r}
x[is.na(x)] <- y[is.na(x)]
```

En dehors des questions de performance, une boucle peut aussi être moins lisible que certaines alternatives. Soit la fonction suivante, qui prend en entrée un vecteur de mots et retourne le nombre total de voyelles qu'il contient.

```{r}
library(stringr)
n_voyelles <- function(mots) {
    nb <- str_count(mots, "[aeiou]")
    sum(nb)
}

n_voyelles(c("le", "chat", "roupille"))
```

Supposons qu'on souhaite appliquer cette fonction à une série de vecteurs de mots contenus dans une liste. On pourrait utiliser une boucle `for` parcourant cette liste, appliquant la fonction, et ajoutant le résultat à un vecteur numérique vide préalablement créé avec  `numeric()`.

```{r}
phrases <- list(
    c("le", "chat", "roupille"),
    c("l'autre", "chat", "roupille", "aussi")
)

res <- numeric()
for (i in seq_along(phrases)) {
    res[i] <- n_voyelles(phrases[[i]])
}
res
```

On verra cependant @sec-purrr que des fonctions permettent de faire ce genre de choses de manière beaucoup plus simple et plus lisible. Ici par exemple on obtiendrait le même résultat avec un simple :

```{r include=FALSE}
library(purrr)
```

```{r}
phrases %>% map_int(n_voyelles)
```

Au final, entre les fonctions vectorisées existantes et les possibilités fournies par `purrr`, il est assez rare de devoir utiliser une boucle directement dans R. Pour autant, il ne faut pas non plus tomber dans l'excès inverse et considérer que tout usage de `for` ou `while` doit être évité : ces fonctions sont parfaitement justifiées dans certains cas de figure, et si vous trouvez une solution qui fonctionne de manière efficace avec une boucle `for`, il n'est pas forcément utile de chercher à la remplacer.



## Ressources {#sec-ressources-boucles}

L'ouvrage *R for Data Science* (en anglais), accessible en ligne, contient [un chapitre sur les boucles for](https://r4ds.had.co.nz/iteration.html#for-loops), et [un chapitre sur les blocs if / else](https://r4ds.had.co.nz/functions.html#conditional-execution).

L'ouvrage *Advanced R* (également en anglais) aborde de manière approfondie [les tests et les boucles](https://adv-r.hadley.nz/control-flow.html).

Sur le blog de [ThinkR](https://thinkr.fr/), [un article détaillé sur l'utilisation des boucles](https://thinkr.fr/comment-faire-des-boucles-en-r-ou-pas/) et les alternatives possibles.

Sur le [blog de Florian Privé](https://privefl.github.io/blog/), un [billet approfondi sur les raisons pour lesquelles les boucles peuvent être lentes](https://privefl.github.io/blog/why-loops-are-slow-in-r/) et sur les cas où il est préférable de ne pas les utiliser.


## Exercices

### `if` et `else`

**Exercice 1.1**

Écrire une fonction `gel` qui prend un argument nommé `temperature` et effectue les actions suivantes :

- si `temperature` est négative, affiche le message "ça gèle" avec la fonction `message()`
- sinon, affiche le message "ça gèle pas" avec la fonction `message()`

::: {.solution-exo}
```{r eval=FALSE}
gel <- function(temperature) {
    if (temperature <= 0) {
        message("ça gèle")
    } else {
        message("ça gèle pas")
    }
}
```
:::


**Exercice 1.2**

Écrire une fonction `meteo` qui prend un argument nommé `temperature` et effectue les actions suivantes :

- si `temperature` est inférieure à 0, affiche le message "ça caille" avec la fonction `message()`
- si `temperature` est comprise entre 0 et 15, affiche le message "fais pas chaud"
- si `temperature` est comprise entre 15 et 30, affiche le message "on est pas mal"
- si `temperature` est supérieure à 30, affiche le message "tous à Miribel"

::: {.solution-exo}

```{r eval=FALSE}
meteo <- function(temperature) {
    if (temperature < 0) {
        message("ça caille")
    } else if (temperature < 15) {
        message("fais pas chaud")
    } else if (temperature < 30) {
        message("on est pas mal")
    } else {
        message("tous à Miribel")
    }
}
# Ou bien
meteo <- function(temperature) {
    if (temperature < 0) {
        message("ça caille")
    }
    if (temperature >= 0 && temperature < 15) {
        message("fais pas chaud")
    }
    if (temperature >= 15 && temperature < 30) {
        message("on est pas mal")
    }
    if (temperature >= 30) {
        message("tous à Mriribel")
    }
}
```
:::


**Exercice 1.3**

Écrire une fonction `avertissement` qui prend deux arguments `pluie` et `parapluie` et qui effectue les opérations suivantes :

- si `pluie` vaut `TRUE` et `parapluie` vaut `FALSE`, affiche "mouillé" avec la fonction `message()`
- si `pluie` vaut `TRUE` et `parapluie` vaut `TRUE`, affiche "bien vu"
- si `pluie` vaut `FALSE`, affiche "RAS"

::: {.solution-exo}
```{r eval=FALSE}
avertissement <- function(pluie, parapluie) {
    if (pluie && !parapluie) {
        message("mouillé")
    }
    if (pluie && parapluie) {
        message("bien vu")
    }
    if (!pluie) {
        message("RAS")
    }
}
```
:::



### Contrôle de l'exécution

**Exercice 2.1**

Créer une fonction `moyenne_arrondie`, qui prend en argument un vecteur `x` et un argument facultatif `decimales`. La fonction doit effectuer les opérations suivantes :

- calculer la moyenne du vecteur
- si `decimales` est défini, arrondir la moyenne au nombre de décimales correspondant avec la fonction `round()`
- retourner le résultat

::: {.solution-exo}
```{r eval=FALSE}
moyenne_arrondie <- function(x, decimales = NULL) {
    moyenne <- mean(x)
    if (!is.null(decimales)) {
        moyenne <- round(moyenne, decimales)
    }
    moyenne
}
```
:::


**Exercice 2.2**

Créer une fonction `etendue` qui retourne la différence entre la plus grande et la plus petite valeur d'un vecteur.

::: {.solution-exo}
```{r eval=FALSE}
etendue <- function(x) {
    max(x) - min(x)
}
```
:::


Modifier la fonction pour qu'elle retourne `NA` si le vecteur passé en argument n'est pas numérique.

::: {.solution-exo}
```{r eval=FALSE}
etendue <- function(x) {
    if (!is.numeric(x)) {
        return(NA)
    }
    max(x) - min(x)
}
```
:::


Modifier à nouveau la fonction pour qu'elle affiche un avertissement avant de renvoyer la valeur `NA`.

::: {.solution-exo}
```{r eval=FALSE}
etendue <- function(x) {
    if (!is.numeric(x)) {
        warning("x doit être numérique")
        return(NA)
    }
    max(x) - min(x)
}
```
:::


**Exercice 2.3**

Créer une fonction `proportion` qui prend en argument un vecteur et retourne les valeurs de ce vecteur divisée par leur somme.

::: {.solution-exo}
```{r eval=FALSE}
proportion <- function(x) {
    x / sum(x)
}
```
:::

Essayer d'exécuter `proportion(c(-2, 1, 1))`. Pourquoi obtient-on ce résultat ?

::: {.solution-exo}
Comme la somme des éléments du vecteur vaut 0, lorsqu'on divise chaque élément par cette valeur on obtient l'infini (`Inf`), soit négatif soit positif selon le signe de l'élément divisé.
:::

Modifier la fonction pour qu'elle retourne un message d'erreur si la somme des éléments du vecteur vaut 0.

::: {.solution-exo}
```{r eval=FALSE}
proportion <- function(x) {
    if (sum(x) == 0) {
        stop("la somme des éléments de x vaut zéro")
    }
    x / sum(x)
}
```
:::


### Boucles

**Exercice 3.1**

Charger le jeu de données `hdv2003` de l'extension `questionr` avec :

```{r}
library(questionr)
data(hdv2003)
```

À l'aide d'une boucle `for`, parcourir les noms des variables de `hdv2003`. Si la variable en question est numérique, faire l'histogramme de la variable avec la fonction `hist()`.

::: {.solution-exo}
```{r eval=FALSE}
for (name in names(hdv2003)) {
    variable <- hdv2003[, name]
    if (is.numeric(variable)) {
        hist(variable)
    }
}
```
:::

Ajouter le nom de la variable comme titre du graphique en utilisant l'argument `main` de `hist()`.

::: {.solution-exo}
```{r eval=FALSE}
for (name in names(hdv2003)) {
    variable <- hdv2003[, name]
    if (is.numeric(variable)) {
        hist(variable, main = name)
    }
}
```
:::

**Exercice 3.2**

La fonction `readline()` permet de lire une chaîne de caractère saisie au clavier de la manière suivante :

```{r eval = FALSE}
reponse <- readline("Quelle est votre réponse ?")
```

Écrire le code qui effectue les opérations suivantes :

- Afficher le message "Quel est le plus grand sociologue de tous les temps ?" et demander la réponse à l'utilisateur
- Si la réponse saisie est "Tonton Michel", afficher "Bingo !"
- Sinon, afficher "Nope"

::: {.solution-exo}
```{r eval=FALSE}
reponse <- readline("Quel est le plus grand sociologue de tous les temps ?")
if (reponse == "Tonton Michel") {
    message("Bingo !")
} else {
    message("Nope !")
}
```
:::

À l'aide d'une boucle `while()`, modifier le code précédent pour que la question soit répétée jusqu'à ce que l'utilisateur saisisse "Tonton Michel".

::: {.solution-exo}

```{r eval=FALSE}
reponse <- ""
while (reponse != "Tonton Michel") {
    reponse <- readline("Quel est le plus grand sociologue de tous les temps ?")
    if (reponse == "Tonton Michel") {
        message("Bingo !")
    } else {
        message("Nope !")
    }
}
```
:::


**Exercice 3.3**

À l'aide d'une boucle `for`, écrire une fonction `somme_positifs` qui prend en argument un vecteur et retourne la somme de tous les nombres positifs qu'il contient.

::: {.solution-exo}
```{r eval=FALSE}
somme_positifs <- function(x) {
    somme <- 0
    for (item in x) {
        if (item > 0) {
            somme <- somme + item
        }
    }
    somme
}
```
:::

Réécrire cette fonction pour qu'elle retourne le même résultat mais sans utiliser de boucle.

::: {.solution-exo}
```{r eval=FALSE}
somme_positifs <- function(x) {
    sum(x[x > 0])
}
```
:::


**Exercice 3.4**

En utilisant une boucle `for`, créer une fonction `somme_premiers_positifs` qui prend en argument un vecteur et retourne la somme de tous les nombres positifs qu'il contient en partant du début du vecteur et en s'arrêtant au premier élément négatif (on pourra recopier et modifier la première fonction `somme_positifs` de l'exercice précédent).

::: {.solution-exo}
```{r eval=FALSE}
somme_premiers_positifs <- function(x) {
    somme <- 0
    for (item in x) {
        if (item < 0) {
            break
        }
        somme <- somme + item
    }
    somme
}
```
:::

*Facultatif :* réécrire la fonction pour qu'elle retourne le même résultat sans utiliser de boucle `for`.

::: {.solution-exo}
```{r eval=FALSE}
somme_premiers_positifs <- function(x) {
    negatifs <- which(x < 0)
    if (length(negatifs) == 0) {
        return(sum(x))
    }
    premier_negatif <- min(negatifs)
    sum(head(x, premier_negatif - 1))
}
```
:::

**Exercice 3.5**

Soit la fonction `pile_ou_face` suivante, qui simule un jet de pièce :

```{r}
pile_ou_face <- function() {
    alea <- runif(1)
    if (alea < 0.5) {
        result <- "pile"
    } else {
        result <- "face"
    }
    result
}
```

Modifier cette fonction en utilisant une boucle `for` pour qu'elle accepte un argument `n` et retourne un vecteur comprenant le résultat de `n` tirages.

```{r echo=FALSE, ref.label='if65'}
```

```{r}
pile_ou_face(4)
```

::: {.solution-exo}
```{r if65, eval=FALSE}
pile_ou_face <- function(n) {
    tirages <- character()
    for (i in seq_len(n)) {
        alea <- runif(1)
        if (alea < 0.5) {
            tirages <- c(tirages, "pile")
        } else {
            tirages <- c(tirages, "face")
        }
    }
    tirages
}
```
:::

Réécrire la fonction pour qu'elle retourne le même résultat sans utiliser de boucle `for`.

::: {.solution-exo}
```{r eval=FALSE}
pile_ou_face <- function(n) {
    alea <- runif(n)
    result <- ifelse(alea < 0.5, "pile", "face")
    result
}
# Ou bien, encore plus simple
pile_ou_face <- function(n) {
    sample(c("pile", "face"), size = n, replace = TRUE)
}
```
:::