15-dplyr-avance.qmd

# `dplyr` avancé

{{< include _setup.qmd >}}

L'extension `dplyr` a déjà été présentée @sec-dplyr. On va voir ici comment aller un peu plus loin dans l'utilisation du *package*, notamment en utilisant nos propres fonctions et en appliquant des transformations à des ensembles de colonnes.

On commence par charger les extensions du *tidyverse* ainsi que les jeux de données `hdv2003` et `rp2018` de l'extension `questionr`.

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

```{r include=FALSE}
hdv2003 <- as_tibble(hdv2003)
rp2018 <- as_tibble(rp2018)
```

## Appliquer ses propres fonctions 

### Exemple avec `mutate`

Soit le jeu de données fictif suivant, dont chaque ligne représente un individu pour lequel on dispose de sa PCS, celle de ses parents, son âge et celui de ses enfants.

```{r}
df <- tribble(
    ~id, ~pcs, ~pcs_pere, ~pcs_mere, ~age, ~`age enf1`, ~`age enf2`, ~`age enf3`,
      1,  "5",       "5",       "6",   25,           2,          NA,          NA,
      2,  "3",       "3",       "2",   45,          12,           8,           2,
      3,  "4",       "2",       "5",   29,           7,          NA,          NA,
      4,  "2",       "1",       "4",   32,           6,           3,          NA,
      5,  "1",       "4",       "3",   65,          39,          36,          28,
      6,  "6",       "6",       "6",   51,          18,          12,          NA,
      7,  "5",       "4",       "6",   37,           8,           4,           1,
      8,  "3",       "3",       "1",   42,          16,          10,           5
)

df
```

Dans ce tableau les PCS sont indiquées sous forme de codes : il serait plus lisible de les avoir sous forme d'intitulés de catégorie socio-professionnelle. On a vu @sec-recode qu'on peut effectuer ce recodage avec la fonction `fct_recode()` de l'extension `forcats`.

```{r results="hide"}
df %>%
    mutate(
        pcs = fct_recode(pcs,
            "Agriculteur" = "1",
            "Indépendant" = "2",
            "Cadre" = "3",
            "Intermédiaire" = "4",
            "Employé" = "5",
            "Ouvrier" = "6"
        )
    )
```

Plutôt que d'intégrer le code du recodage directement dans le `mutate()`, on peut l'extraire en créant une fonction.

```{r}
recode_pcs <- function(v) {
    fct_recode(v,
        "Agriculteur" = "1",
        "Indépendant" = "2",
        "Cadre" = "3",
        "Intermédiaire" = "4",
        "Employé" = "5",
        "Ouvrier" = "6"
    )
}
```

On peut dès lors simplifier notre `mutate` en appelant notre nouvelle fonction.

```{r results="hide"}
df %>%
    mutate(pcs = recode_pcs(pcs))
```

Premier avantage : on gagne en lisibilité. On a déplacé le code d'une opération spécifique dans une fonction avec un nom "parlant", ce qui permet de savoir facilement à quoi elle sert. Et on a simplifié notre `mutate` qui est désormais plus lisible parce qu'il fait apparaître la logique de nos opérations (on veut recoder les PCS) sans en inclure les détails.

Le deuxième avantage évident, comme pour toute fonction, est qu'on peut la réutiliser pour appliquer ce recodage à plusieurs variables. Ainsi, si on veut recoder de la même manière `pcs` et `pcs_mere`, il suffit de faire :

```{r results="hide"}
df %>%
    mutate(
        pcs = recode_pcs(pcs),
        pcs_mere = recode_pcs(pcs_mere)
    )
```

Le code est plus court, plus lisible, on évite les erreurs de copier/coller, et si on souhaite modifier le recodage on n'a à intervenir qu'à un seul endroit en modifiant notre fonction.

### Exemple avec `summarise`

Autre exemple, cette fois sur le jeu de données `rp2018`. Imaginons qu'on souhaite calculer, pour chaque région, le pourcentage de communes dont le nom se termine par une série de caractères donnée : par exemple, le pourcentage de communes dont le nom se termine par "ac".

Comme il ne s'agit pas forcément d'une question triviale, on va décomposer le problème et rappeler (comme vu @sec-str-detect) que la fonction `str_detect()` de l'extension `stringr` permet de détecter quels éléments d'un vecteur de chaînes de caractères correspondent à une expression régulière. Ainsi, si on veut détecter si un nom de commune (variable `rp2018$commune`) se termine par `"ac"`, on utilisera :

```{r results="hide"}
str_detect(rp2018$commune, "ac$")
```

::: {.callout-note}
Le symbole \\$ dans l'expression régulière `"ac$"` représente la fin de la chaîne de caractères. Il permet de s'assurer qu'on ne détecte que les noms de communes se terminant par "ac" (comme "Fige**ac**"), et pas ceux contenant "ac" à un autre endroit (comme "Arc**ac**hon").
:::

Si on veut compter le nombre de communes pour lesquelles on a détecté une terminaison en "ac", on peut utiliser un idiome courant en R et appliquer la fonction `sum()` au résultat précédent : les `TRUE` du résultat du `str_detect` sont alors convertis en 1, les `FALSE` en 0, et le `sum()` renverra donc le nombre de `TRUE`.

```{r}
sum(str_detect(rp2018$commune, "ac$"))
```

Si on souhaite convertir ce résultat en pourcentage, il faut qu'on divise par le nombre total de communes, et qu'on multiplie par 100.

```{r}
sum(str_detect(rp2018$commune, "ac$")) / length(rp2018$commune) * 100
```

On crée une fonction nommée `prop_suffixe` qui a pour objectif d'effectuer ce calcul. Elle prend en entrée deux arguments : un vecteur de chaînes de caractères et un suffixe à détecter, et retourne le pourcentage d'éléments du vecteur se terminant par le suffixe. On rajoute nous-même le "$" à la fin du suffixe en question pour faciliter l'usage de la fonction. 

Le résultat final est le suivant :

```{r}
prop_suffixe <- function(v, suffixe) {
    # On ajoute $ à la fin du suffixe pour capturer uniquement en fin de chaîne
    suffixe <- paste0(suffixe, "$")
    # Détection du suffixe
    nb_detect <- sum(str_detect(v, suffixe))
    # On retourne le pourcentage
    nb_detect / length(v) * 100
}
```

On peut utiliser notre fonction de la manière suivante :

```{r}
prop_suffixe(rp2018$commune, "ac")
```

On a donc dans notre jeu de données `r round(prop_suffixe(rp2018$commune, "ac"), 2)`% de communes dont le nom se termine par "ac"^[Attention, le jeu de données ne comporte que les communes de plus de 2000 habitants.].

Si maintenant on souhaite calculer ce pourcentage pour toutes les régions françaises, il suffit d'appeler notre fonction dans un `summarise` :

```{r}
rp2018 %>%
    group_by(region) %>%
    summarise(prop_ac = prop_suffixe(commune, "ac")) %>%
    arrange(desc(prop_ac))
```

L'avantage d'avoir créé une fonction pour effectuer cette opération et qu'on peut du coup très facilement faire le même calcul en faisant varier le suffixe recherché.

```{r}
rp2018 %>%
    group_by(region) %>%
    summarise(prop_ac = prop_suffixe(commune, "ieu")) %>%
    arrange(desc(prop_ac))
```

En créant une fonction plutôt qu'en mettant notre code directement dans le `summarise` on a un script plus lisible, plus facile à maintenir, et des fonctionnalités facilement réutilisables.

### Exemple avec `rename_with`

On a vu @sec-select-rename que `dplyr` propose la fonction `rename()` pour renommer des colonnes d'un tableau de données. On peut l'utiliser par exemple pour remplacer un espace par un `_` dans le nom d'une variable de `df`.

```{r results="hide"}
df %>% rename("age_enf1" = "age enf1")
```

Supposons maintenant qu'on souhaite appliquer la même transformation à l'ensemble des variables de `df`. Une solution pour cela est d'utiliser la fonction `rename_with()`, toujours fournie par `dplyr`, qui prend en argument non pas une correspondance `"nouveau nom" = "ancien nom"` mais une fonction qui sera appliquée à l'ensemble des noms de colonnes.

Par exemple, si on souhaite convertir tous les noms de colonnes en majuscules, on peut passer comme argument la fonction `str_to_upper()` de `stringr`.

```{r}
df %>% rename_with(str_to_upper)
```

Pour remplacer les espaces par des `_`, on va d'abord créer une fonction *ad hoc* qui utilise `str_replace_all`.

```{r}
remplace_espaces <- function(v) {
    str_replace_all(v, " ", "_")
}
```

Dès lors, on peut appliquer cette fonction à l'ensemble de nos noms de variables :

```{r}
df %>% rename_with(remplace_espaces)
```

Certain.es lectrices et lecteurs attentives auront peut-être noté que le même résultat peut être obtenu en utilisant `remplace_espaces()` avec la fonction `names()`. 

```{r eval=FALSE}
names(df) <- remplace_espaces(names(df))
```

L'avantage de `rename_with()` c'est qu'elle peut s'intégrer dans un pipeline de dplyr, et, comme nous allons le voir un peu plus loin, permet si nécessaire de n'appliquer cette transformation qu'à certaines colonnes seulement.


## `across()` : appliquer des fonctions à plusieurs colonnes {#sec-across}

### Appliquer une fonction à plusieurs colonnes

On a défini précédemment une fonction qui recode les modalités d'une variable PCS et on a vu comment appliquer ce recodage à deux variables de `df`.

```{r results="hide"}
recode_pcs <- function(v) {
    fct_recode(v,
        "Agriculteur" = "1",
        "Indépendant" = "2",
        "Cadre" = "3",
        "Intermédiaire" = "4",
        "Employé" = "5",
        "Ouvrier" = "6"
    )
}

df %>%
    mutate(
        pcs = recode_pcs(pcs),
        pcs_mere = recode_pcs(pcs_mere)
    )
```

Supposons qu'on souhaite appliquer ce recodage à toutes les variables PCS de notre tableau. On pourrait évidemment créer autant de lignes que nécessaires dans notre `mutate`, mais on peut aussi utiliser la fonction `across()` de `dplyr`, qui facilite justement ce type d'opérations.

`across()` prend deux arguments principaux :

- la définition d'un ensemble de colonnes de notre tableau de données
- une ou plusieurs fonctions à appliquer aux colonnes sélectionnées

Il existe de nombreuses manières de définir les colonnes qu'on souhaite transformer : celles-ci sont en fait les mêmes que celles offertes par des verbes de `dplyr` comme `select()`.

Une première possibilité est d'utiliser `c()` en lui passant les noms des variables (on notera qu'on n'est pas obligés de mettre ces noms entre guillemets).

```{r}
df %>%
    mutate(
        across(
            c(pcs, pcs_mere),
            recode_pcs
        )
    )
```

Une autre possibilité est d'utiliser `:`, qui permet de définir une plage de colonnes en lui indiquant la colonne de début et la colonne de fin. Ainsi dans l'exemple suivant notre recodage est appliqué à toutes les colonnes situées entre `pcs` et `pcs_mere` (incluses).

```{r}
df %>%
    mutate(
        across(
            pcs:pcs_pere,
            recode_pcs
        )
    )
```

On peut aussi sélectionner les variables via leurs noms. On peut ainsi choisir les variables qui commencent par une certaine chaîne de caractères via la fonction `starts_with()`, celles qui se terminent ou qui contiennent certains caractères avec `ends_with()` et `contains()`.

```{r}
df %>%
    mutate(
        across(
            starts_with("pcs"),
            recode_pcs
        )
    )
```


`across()` fonctionne dans un `mutate`, mais aussi dans un `summarise`. Dans l'exemple suivant, on calcule la moyenne de toutes les variables qui contiennent "enf".

```{r}
df %>%
    summarise(
        across(
            contains("enf"),
            mean
        )
    )
```


De manière similaire, la fonction `num_range()` permet de sélectionner des colonnes ayant un préfixe commun suivi d'un indicateur numérique, comme `x1`, `x2`... Par exemple la syntaxe suivante sélectionnerait toutes les colonnes de `Q01` à `Q12` :

```{r eval=FALSE}
across(num_range("Q", 1:12, width = 2))
```


On peut également sélectionner des colonnes via une condition avec la fonction `where()`. Celle-ci prend elle-même en argument une fonction qui doit renvoyer `TRUE` ou `FALSE`, et ne conserve que les colonnes qui correspondent à des `TRUE`.

Dans l'exemple suivant, on applique la fonction `mean` seulement aux colonnes de `df` pour lesquelles la fonction `is.numeric` renvoie `TRUE`.

```{r}
df %>%
    summarise(
        across(
            where(is.numeric),
            mean
        )
    )
```

Pour des conditions plus complexes, on doit parfois définir soi-même la fonction passée à `where()`. Dans l'exemple suivant on calcule la moyenne uniquement pour les variables de `df` qui sont numériques et n'ont pas de valeurs manquantes.

```{r}
no_na <- function(v) {
    is.numeric(v) && sum(is.na(v)) == 0
}

df %>%
    summarise(
        across(
            where(no_na),
            mean
        )
    )
```

Il est même possible, pour les cas les plus complexes, de combiner plusieurs sélections avec les opérateurs `&`, `|` et `!`. L'exemple suivant applique la fonction `mean()` à toutes les colonnes numériques de `df`, sauf à la colonne `id`.

```{r}
df %>%
    summarise(
        across(
            where(is.numeric) & !id,
            mean
        )
    )
```

Enfin, la fonction spéciale `everything()` permet de sélectionner la totalité des colonnes d'un tableau. Dans l'exemple suivant, on applique `n_distinct()` pour afficher le nombre de valeurs distinctes de toutes les variables de `df`.

```{r}
df %>%
    summarise(
        across(
            everything(),
            n_distinct
        )
    )
```

Ces différentes manières de sélectionner un ensemble de colonnes sont appelées *tidy selection*. Il y a encore d'autres possibilités de sélection, pour avoir un aperçu complet on pourra se référer à [la page de documentation de la fonction select()](https://dplyr.tidyverse.org/reference/select.html).

::: {.callout-note}
Une erreur de syntaxe fréquente est de mettre la sélection des colonnes dans l'appel à `across()`, mais pas la fonction qu'on souhaite appliquer.

Ainsi le code suivant génèrera une erreur :

`mutate(across(pcs:pcs_mere), recode_pcs)`

Il faut bien penser à passer la fonction comme argument du `across()`, donc à l'intérieur de ses parenthèses.

`mutate(across(pcs:pcs_mere, recode_pcs))`
:::

### Passer des arguments supplémentaires à la fonction appliquée

Par défaut, si on passe des arguments supplémentaires à `across()`, ils seront automatiquement transmis comme arguments à la fonction appliquée.

Dans l'exemple vu précédemment, on appliquait `mean()` à toutes les variables d'âge de `df`. Or comme certaines colonnes ont des valeurs manquantes, leur résultat vaut `NA`.

```{r eval=FALSE}
df %>%
    summarise(
        across(
            starts_with("age"),
            mean
        )
    )
```

Si on préfère que `mean()` soit appelée avec l'argument `na.rm = TRUE`, on pourrait définir explicitement une fonction à part qui utilise cet argument :

```{r eval=FALSE}
mean_sans_na <- function(x) {
    max(x, na.rm = TRUE)
}

df %>%
    summarise(
        across(
            starts_with("age"),
            mean_sans_na
        )
    )
```

Mais on peut faire plus simple, car tout argument supplémentaire passé à `across()` est transmis directement à la fonction appelée. Il est donc possible de faire :

```{r}
df %>%
    summarise(
        across(
            starts_with("age"),
            max,
            na.rm = TRUE
        )
    )
```

### Noms des colonnes créées par un `mutate`

Par défaut, lorsqu'on utilise `across()` dans un `mutate`, les nouvelles colonnes portent le même nom que les colonnes d'origine, ce qui signifie que ces dernières sont "écrasées" par les nouvelles valeurs.

Ainsi dans l'exemple suivant, les valeurs d'origine des colonnes PCS ont été écrasées par le résultat du recodage.

```{r eval=FALSE}
df %>%
    mutate(
        across(
            starts_with("pcs"),
            recode_pcs
        )
    )
```

Si on préfère créer de nouvelles colonnes, on doit indiquer la manière de les nommer en utilisant l'argument `.names` de `across()`. Celui prend comme valeur une chaîne de caractère dans laquelle le motif `{.col}` sera remplacé par le nom de la colonne d'origine.

Ainsi, si on souhaite plutôt que les variables recodées soient stockées dans de nouvelles colonnes nommées avec le suffixe `_rec`, on peut utiliser :

```{r cache=FALSE}
df %>%
    mutate(
        across(
            starts_with("pcs"),
            recode_pcs,
            .names = "{.col}_rec"
        )
    )
```


### Appliquer plusieurs fonctions à plusieurs colonnes

`across()` offre également la possibilité d'appliquer plusieurs fonctions à un ensemble de colonnes. Dans ce cas, plutôt que de lui passer une seule fonction comme deuxième argument, on lui passe une liste nommée de fonctions.

Le code suivant calcule le minimum et le maximum pour les variables d'âge de `df`.

```{r}
df %>%
    summarise(
        across(
            starts_with("age"),
            list(minimum = min, maximum = max)
        )
    )
```

Par défaut les nouvelles variables sont nommées sous la forme `{nom_variable}_{nom_fonction}`, mais on peut personnaliser cette règle en ajoutant un argument `.names` à `across()`. Cet argument est une chaîne de caractères dans laquelle `{.col}` sera remplacé par le nom de la colonne courante, et `{.fn}` par le nom de la fonction.

```{r}
df %>%
    summarise(
        across(
            starts_with("age"),
            list(minimum = min, maximum = max),
            .names = "{.fn}_{.col}"
        )
    )
```

### Renommer plusieurs colonnes avec une fonction

On a vu précédemment qu'on peut utiliser `rename_with()` pour renommer les colonnes d'un tableau de données à l'aide d'une fonction.

```{r results="hide"}
remplace_espaces <- function(v) {
    str_replace_all(v, " ", "_")
}

df %>% rename_with(remplace_espaces)
```

Par défaut, `rename_with()` applique la fonction de renommage à l'ensemble des colonnes du tableau. Il est cependant possible de lui indiquer de ne renommer que certaines de ces colonnes. Pour cela, on peut lui ajouter un argument supplémentaire nommé `.cols`, dont la syntaxe est exactement la même que pour `across()` ou `select()`.

Par exemple, le code suivant convertit en majuscule uniquement les noms des colonnes `id` et `poids`.

```{r}
df %>%
    rename_with(str_to_upper, .cols = starts_with("pcs"))
```

Et le code suivant remplace les espaces par des `_` uniquement pour les colonnes dont le nom contient "enf".

```{r}
df %>%
    rename_with(remplace_espaces, .cols = contains("enf"))
```


## Fonctions anonymes et syntaxes abrégées {#sec-syntaxes-abregees}

Dans les sections précédentes, nous avons rencontré plusieurs fonctions, comme `rename_with()` ou `across()`, qui prennent  une fonction en argument.

Par exemple, dans l'utilisation suivante de `rename_with()`, on avait créé une fonction `remplace_espaces()`.

```{r results="hide"}
remplace_espaces <- function(v) {
    str_replace_all(v, " ", "_")
}

df %>% rename_with(remplace_espaces)
```

Le fait de créer une fonction à part pour une opération d'une seule ligne ne se justifie pas forcément, surtout si on n'utilise pas cette fonction ailleurs dans notre code. Dans, ce cas, on peut définir notre fonction directement dans l'appel à `rename_with()` en utilisant une *fonction anonyme*, déjà introduites @sec-fonctions-anonymes.

```{r results="hide"}
df %>%
    rename_with(function(v) {
        str_replace_all(v, " ", "_")
    })
```

Cette notation est assez pratique et souvent utilisée pour les fonctions à usage unique, ne serait-ce que pour s'économiser le fait de devoir lui trouver un nom pertinent.

La syntaxe étant un peu lourde, il existe deux alternatives permettant une définition plus "compacte". 

- La première alternative est propre aux packages du *tidyverse* (notamment `dplyr` et `purrr`), et ne fonctionnera pas pour les fonctions n'appartenant pas à ces packages. Il s'agit d'utiliser une syntaxe de type "formule" : le corps de la formule contient les instructions de la fonction, et les arguments sont nommés `.x` (ou `.`) s'il n'y en a qu'un, `.x` et `.y` s'il y en a deux, et `..1`, `..2`, etc. s'ils sont plus nombreux.
- La deuxième alternative est une syntaxe apparue avec la version 4.1 de R, qui permet de remplacer `function(...)` par le raccourci `\(...)`.

Ainsi les définitions suivantes sont équivalents :

```{r eval=FALSE}
# Fonctionne partout et tout le temps
function(v) { v + 2 }
# Fonctionne uniquement dans les fonctions du tidyverse
~ { .x + 2 }
# Fonctionne uniquement à partir de R 4.1
\(v) { v + 2 }
```

De même que les définitions suivantes :

```{r eval=FALSE}
function(v1, v2) {
    res <- v1 / v2
    round(res, 1)
}

~ {
    res <- .x / .y
    round(res, 1)
}

\(v1, v2) {
    res <- v1 / v2
    round(res, 1)
}
```

Quand la fonction anonyme est constituée d'une seule instruction, on peut supprimer les accolades dans sa définition.

```{r eval=FALSE}
function(x) x + 2
~ .x + 2
\(x) x + 2
```

On pourra du coup, si on le souhaite, utiliser ces syntaxes compactes dans notre `rename_with()` pour définir notre fonction anonyme.

```{r results="hide"}
df %>%
    rename_with(~ str_replace_all(.x, " ", "_") )

df %>%
    rename_with( \(x) str_replace_all(x, " ", "_") )
```

Cette syntaxe peut être utilisée partout où on peut passer une fonction comme argument et donc définir des fonctions anonymes. Dans cet exemple déjà vu précédemment, on passe la fonction `no_na` comme argument de `where()`.

```{r results="hide"}
no_na <- function(v) {
    is.numeric(v) && sum(is.na(v)) == 0
}

df %>%
    summarise(
        across(
            where(no_na),
            mean
        )
    )
```

On peut donc remplacer la fonction `no_na` par une fonction anonyme définie directement dans le `where()`.

```{r results="hide"}
df %>%
    summarise(
        across(
            where(function(v) { is.numeric(v) && sum(is.na(v)) == 0 }),
            mean
        )
    )
```

Et du coup utiliser une des deux syntaxes "compactes".

```{r eval=FALSE}
df %>%
    summarise(
        across(
            where(~ is.numeric(.x) && sum(is.na(.x)) == 0),
            mean
        )
    )

df %>%
    summarise(
        across(
            where(\(v) is.numeric(v) && sum(is.na(v)) == 0),
            mean
        )
    )
```



## `rowwise()` et `c_across()` : appliquer une transformation ligne par ligne

Soit le tableau de données suivant, qui contient des évaluations de restaurants sur quatre critères différents^[Un nom de salon de coiffure s'est glissé dans cette liste de restaurants. Saurez-vous le retrouver ?] :

```{r}
restos <- tribble(
    ~nom,                       ~cuisine, ~decor, ~accueil, ~prix,
    "La bonne fourchette",             4,      2,        5,     4,
    "La choucroute de l'amer",         3,      3,        2,     3,
    "L'Hair de rien",                  1,      4,        4,     3,
    "La blanquette de Vaulx",          5,      4,        4,     5,
)

restos
```

Imaginons qu'on souhaite faire la moyenne, pour chaque restaurant, des critères `decor` et `accueil`. On pourrait être tentés d'utiliser `mean()` de la manière suivante :

```{r}
restos %>%
    mutate(
        decor_accueil = mean(c(decor, accueil))
    )
```

Si on regarde le résultat, on constate qu'il ne correspond pas à ce que l'on souhaite puisque toutes les valeurs sont les mêmes.

Que s'est-il passé ? En fait le `mutate` s'est appliqué sur la totalité du tableau. Ceci signifie que dans `mean(c(decor, accueil))`, les objets `decor` et `accueil` correspondent à la totalité des valeurs de chaque variable. On a donc concaténé ces deux vecteurs et calculé la moyenne, qui est du coup la même pour chaque ligne.

La valeur obtenue correspond aux résultat de :

```{r}
mean(c(restos$decor, restos$accueil))
```

Ce que nous souhaitons ici, c'est calculer la moyenne non pas pour l'ensemble du tableau mais *pour chaque ligne*. Pour cela, on va utiliser la fonction `rowwise()` : celle-ci est équivalente à un `group_by()` qui créerait autant de groupes qu'il y a de lignes dans notre tableau.

```{r}
restos %>% rowwise()
```

Quant notre tableau est groupé via un `rowwise()`, les opérations s'effectuent sur un tableau constitué uniquement de la ligne courante. Si on calcule la moyenne précédente, on obtient désormais le bon résultat.

```{r}
restos %>%
    rowwise() %>%
    mutate(decor_accueil = mean(c(decor, accueil)))
```


Supposons qu'on souhaite désormais calculer la moyenne de l'ensemble des critères. On peut évidemment reprendre le code précédent en saisissant toutes les variables concernées.

```{r}
restos %>%
    rowwise() %>%
    mutate(moyenne = mean(c(decor, accueil, cuisine, prix)))
```

Lister les variables de cette manière peut vite devenir pénible si le nombre de variables est important. C'est pourquoi `dplyr` propose la fonction `c_across()` : celle-ci permet de sélectionner des colonnes de la même manière que `select()` ou `across()`, et retourne un vecteur constitué des valeurs concaténées de ces colonnes.

L'exemple suivant calcule la moyenne de toutes les colonnes comprises entre `decor` et `prix`, en utilisant l'opérateur `:`.

```{r}
restos %>%
    rowwise() %>%
    mutate(
        moyenne = mean(c_across(decor:prix))
    )
```

Comme pour `across()` ou `select()`, on peut utiliser la fonction `where()` pour calculer la moyenne sur toutes les colonnes numériques.

```{r}
restos %>%
    rowwise() %>%
    mutate(
        moyenne = mean(
            c_across(where(is.numeric))
        )
    )
```


L'utilisation de `rowwise()` et `c_across()` est intéressante principalement quand il n'existe pas de fonction vectorisée pour la transformation qu'on souhaite appliquer. Quand elle existe, il est en général plus simple et plus rapide de l'utiliser.

Par exemple, pour trouver la valeur la plus élevée par restaurant, on pourrait être tenté d'utiliser le code suivant :

```{r}
restos %>%
    rowwise() %>%
    summarise(note_max = max(c(decor, accueil)))
```

Il est cependant plus lisible et plus efficace d'utiliser la fonction `pmax`, qui a justement pour objectif de parcourir des vecteurs en parallèle et de ne conserver que la plus grande valeur.

```{r}
restos %>%
    summarise(note_max = pmax(decor, accueil))
```

Une des limites de `pmax` cependant est qu'on ne peut pas l'utiliser avec `c_across()`, et qu'on ne peut donc pas faire de sélection des colonnes : on est obligés de saisir leurs noms.

```{r}
restos %>%
    summarise(note_max = pmax(cuisine, decor, accueil, prix))
```

Dans certains cas, notamment lorsque les colonnes sont nombreuses ou qu'on ne les a pas identifiées à l'avance, on pourra  donc utiliser `rowwise()` et `c_across()` même quand des alternatives vectorisées existent.

```{r}
restos %>%
    rowwise() %>%
    summarise(
        note_max = max(
            c_across(where(is.numeric))
        )
    )
```



## Ressources

[La page d'aide de la fonction select](https://dplyr.tidyverse.org/reference/select.html) (en anglais) liste toutes les possibilités offertes pour spécifier des ensembles de colonnes d'un tableau de données.

La vignette [Column-wise operations](https://dplyr.tidyverse.org/articles/colwise.html) de `dplyr` (en anglais) présente en détail l'utilisation et les fonctionnalités de `across()`.

La vignette [Row-wise operations](https://dplyr.tidyverse.org/articles/rowwise.html) de `dplyr` (toujours en anglais) présente de manière approfondie l'utilisation de `rowwise()` et `c_across()` pour opérer individuellement sur les lignes d'un tableau de données.


## Exercices

Pour certains des exercices qui suivent on utilisera le jeu de données `starwars` de `dplyr`. On peut le charger avec les instructions suivantes :

```{r}
library(dplyr)
data(starwars)
```

Le jeu de données contient les caractéristiques de 87 personnages présents dans les films : espèce, âge, planète d'origine, etc.

### Appliquer ses propres fonctions

**Exercice 1.1**

Créer une fonction `imc` qui prend en argument un vecteur `taille` (en cm) et un vecteur `poids` (en kg) et retourne les valeurs correspondantes de l'indice de masse corporelle, qui se calcule en divisant le poids en kilos par la taille en mètres au carré.

::: {.solution-exo}
```{r eval=FALSE}
imc <- function(tailles, poids) {
    tailles_m <- tailles / 100
    poids / tailles_m ^ 2
}
```
:::

Utiliser cette fonction pour ajouter une nouvelle variable `imc` au tableau `starwars`.

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    mutate(imc = imc(height, mass))
```
:::

À l'aide de `group_by()` et `summarise()`, utiliser à nouveau cette fonction pour calculer l'IMC moyen selon les valeurs de la variable `species`.

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    group_by(species) %>%
    summarise(
        imc = mean(imc(height, mass), na.rm = TRUE)
    )
```
:::

**Exercice 1.2**

Toujours dans le jeu de données `starwars`, à l'aide d'un `group_by()` et d'un `summarise()`, calculer pour chaque valeur de la variable `sex` la valeur de l'étendue de la variable `height` du jeu de données `starwars`, c'est-à-dire la différence entre sa valeur maximale et sa valeur minimale.

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    group_by(sex) %>%
    summarise(
        etendue_taille = max(height, na.rm = TRUE) - min(height, na.rm = TRUE)
    )
```
:::

En partant du code précédent, créer une fonction `etendue` qui prend en argument un vecteur et retourne la différence entre sa valeur maximale et sa valeur minimale. En utilisant cette fonction, calculer pour chaque valeur de `sex` la valeur de l'étendue des variables `height` et `mass`.

::: {.solution-exo}
```{r eval=FALSE}
etendue <- function(v) {
    max(v, na.rm = TRUE) - min(v, na.rm = TRUE)
}
starwars %>%
    group_by(sex) %>%
    summarise(
        etendue_taille = etendue(height),
        etendue_poids  = etendue(mass)
    )
```
:::


**Exercice 1.3**

On a vu que la fonction suivante permet de calculer le pourcentage des éléments d'un vecteur de chaînes de caractères se terminant par un suffixe passé en argument.

```{r}
prop_suffixe <- function(v, suffixe) {
    # On ajoute $ à la fin du suffixe pour capturer uniquement en fin de chaîne
    suffixe <- paste0(suffixe, "$")
    # Détection du suffixe
    nb_detect <- sum(str_detect(v, suffixe))
    # On retourne le pourcentage
    nb_detect / length(v) * 100
}
```

Modifier cette fonction en une fonction `prop_prefixe` qui retourne le pourcentage d'éléments commençant par un préfixe passé en argument. *Indication :* pour détecter si une chaîne commence par `"ker"`, on utilise l'expression régulière `"^ker"`.

::: {.solution-exo}
```{r eval=FALSE}
prop_prefixe <- function(v, prefixe) {
    # On ajoute $ à la fin du prefixe pour capturer uniquement en début de chaîne
    prefixe <- paste0("^", prefixe)
    # Détection du motif
    nb_detect <- sum(str_detect(v, prefixe))
    # On retourne le pourcentage
    nb_detect / length(v) * 100
}
```
:::

Utiliser `prop_prefixe` dans un `summarise` appliqué à `rp2018` pour calculer le pourcentage de communes commençant par "Saint" selon le département. Ordonner les résultats par pourcentage décroissant.

::: {.solution-exo}
```{r eval=FALSE}
rp2018 %>%
    group_by(departement) %>%
    summarise(
        prop_saint = prop_prefixe(commune, "Saint")
    ) %>%
    arrange(desc(prop_saint))
```
:::

Créer une fonction `tab_prefixe` qui prend un seul argument `prefixe` et renvoie le tableau obtenu à la question précédente pour le préfixe passé en argument. Tester avec `tab_prefixe("Plou")` et `tab_prefixe("Sch")`

::: {.solution-exo}
```{r eval=FALSE}
tab_prefixe <- function(prefixe) {
    rp2018 %>%
        group_by(departement) %>%
        summarise(
            prop = prop_prefixe(commune, prefixe)
        ) %>%
        arrange(desc(prop))
}
```
:::



**Exercice 1.4**

Le vecteur suivant donne, pour chacun des neuf principaux films de la saga *Star Wars*, la date à laquelle ils se déroulent dans l'univers de la saga.

```{r results="hide"}
c(
    "I"    = -32,
    "II"   = -22,
    "III"  = -19,
    "IV"   =   0,
    "V"    =   3,
    "VI"   =   4,
    "VII"  =  34,
    "VIII" =  34,
    "IX"   =  35
)
```

Dans le jeu de données `starwars`, la variable `birth_year` indique l'année de naissance du personnage en "années avant l'an zéro" (une valeur de 19 signifie donc une année de naissance de -19).

Créer une fonction `age_film` qui prend en entrée un vecteur d'années de naissance au même format que `birth_year` ainsi que l'identifiant d'un film, et calcule les âges à la date du film. 

Vérifier avec :

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

```{r}
age_film(starwars$birth_year, "IV")
```

::: {.solution-exo}
```{r dpl14, eval=FALSE}
age_film <- function(annees, film) {
    annees_films <- c(
        "I"    = -32,
        "II"   = -22,
        "III"  = -19,
        "IV"   =   0,
        "V"    =   3,
        "VI"   =   4,
        "VII"  =  34,
        "VIII" =  34,
        "IX"   =  35
    )
    annees_naissance <- -annees
    annee_ref <- annees_films[film]
    annee_ref - annees_naissance
}
```
:::

Utiliser la fonction pour ajouter deux nouvelles variables au tableau `starwars` : `age_iv` qui correspond à l'âge (potentiel) au moment du film IV, et `age_ix` qui correspond à l'âge au moment du film IX.

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    mutate(
        age_iv = age_film(birth_year, "IV"),
        age_ix = age_film(birth_year, "IX"),
    )
```
:::


### `across()`

**Exercice 2.1**

Reprendre la fonction `etendue` de l'exercice 1.2 :

```{r}
etendue <- function(v) {
    max(v, na.rm = TRUE) - min(v, na.rm = TRUE)
}
```

Dans le jeu de données `starwars`, calculer l'étendue des variables `height` et `mass` pour chaque valeur de `sex` à l'aide de `group_by()`, `summarise()` et `across()`.

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    group_by(sex) %>%
    summarise(
        across(
            c(height, mass),
            etendue
        )
    )
```
:::

Toujours à l'aide d'`across()`, appliquer `etendue` à toutes les variables numériques, toujours pour chaque valeur de `sex`.

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    group_by(sex) %>%
    summarise(
        across(
            where(is.numeric),
            etendue
        )
    )
```
:::

En utilisant `&` et `!`, appliquer `etendue` à toutes les variables numériques sauf à celles qui finissent par "year".

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    group_by(sex) %>%
    summarise(
        across(
            where(is.numeric) & !ends_with("year"),
            etendue
        )
    )
```
:::


**Exercice 2.2**

Dans le jeu de données `starwars`, appliquer en un seul `summarise` les fonctions `min` et `max` aux variables `height` et `mass`.

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    summarise(
        across(
            c(height, mass),
            list(min = min, max = max)
        )
    )
```
:::

Si vous ne l'avez pas déjà fait à la question précédente, modifier le code pour que le calcul des valeurs minimales et maximales ne prennent pas en compte les valeurs manquantes.

::: {.solution-exo}
```{r eval=FALSE}
funs <- list(
    min = function(v) { min(v, na.rm = TRUE) },
    max = function(v) { max(v, na.rm = TRUE) }
)
starwars %>%
    summarise(
        across(
            c(height, mass),
            funs
        )
    )
# Autre possibilité : les arguments supplémentaires passés à across() sont
# transmis aux fonctions appliquées
starwars %>%
    summarise(
        across(
            c(height, mass),
            list(min = min, max = max),
            na.rm = TRUE
        )
    )
```
:::


**Exercice 2.3**

Dans le jeu de données `hdv2003`, utiliser `across()` pour transformer les modalités "Oui" et "Non" en `TRUE` et `FALSE` pour toutes les variables de `hard.rock` à `sport`.

::: {.solution-exo}
```{r eval=FALSE}
detecte_oui <- function(v) {
    v == "Oui"
}
hdv2003 %>%
    mutate(
        across(
            hard.rock:sport,
            detecte_oui
        )
    )
```
:::

Ajouter un argument `.names` à `across()` pour que les variables recodées soient stockées dans de nouvelles colonnes nommées avec le suffixe `"_true"`.

::: {.solution-exo}
```{r eval=FALSE}
detecte_oui <- function(v) {
    v == "Oui"
}
hdv2003 %>%
    mutate(
        across(
            hard.rock:sport,
            detecte_oui,
            .names = "{.col}_true"
        )
    )
```
:::


### Fonctions anonymes et notations abrégées

**Exercice 3.1**

Dans un exercice précédent, on a vu que le code ci-dessous permet de calculer l'étendue des variables `height` et `mass` du jeu de données `starwars`.

```{r eval=FALSE}
etendue <- function(v) {
    max(v, na.rm = TRUE) - min(v, na.rm = TRUE)
}

starwars %>%
    group_by(sex) %>%
    summarise(
        across(
            c(height, mass),
            etendue
        )
    )
```

Modifier ce code en supprimant la définition de `etendue` et en utilisant à la place une fonction anonyme directement dans le `across()`.

::: {.solution-exo}

```{r eval=FALSE}
starwars %>%
    group_by(sex) %>%
    summarise(
        across(
            c(height, mass),
            function(v) {
               max(v, na.rm = TRUE) - min(v, na.rm = TRUE)
            }
        )
    )
```
:::


Modifier à nouveau ce code pour utiliser la syntaxe abrégée de type "formule" du *tidyverse*.

::: {.solution-exo}

```{r eval=FALSE}
starwars %>%
    group_by(sex) %>%
    summarise(
        across(
            c(height, mass),
            ~ max(.x, na.rm = TRUE) - min(.x, na.rm = TRUE)
        )
    )
```
:::



**Exercice 3.2**

Soit le code suivant, qui renomme les colonnes du tableau `starwars` de type liste en leur ajoutant le préfixe "liste_".

```{r eval=FALSE}
ajoute_prefixe_liste <- function(nom) {
    paste0("liste_", nom)
}

starwars %>%
    rename_with(ajoute_prefixe_liste, .cols = where(is.list))
```

Réécrire ce code avec une fonction anonyme en utilisant les trois notations : 

- classique (avec `function()`)
- formule (du *tidyverse*)
- compacte (à partir de R 4.1)

::: {.solution-exo}
```{r eval=FALSE}
# Classique
starwars %>%
    rename_with(
        function(nom) { paste0("liste_", nom) },
        .cols = where(is.list)
    )
# Formule
starwars %>%
    rename_with(
        ~ paste0("liste_", .x),
        .cols = where(is.list)
    )
# Compacte
starwars %>%
    rename_with(
        \(nom) paste0("liste_", nom),
        .cols = where(is.list)
    )
```
:::

**Exercice 3.3**

Le code suivant indique, pour chaque région du jeu de données `rp2018`, le nom de la commune ayant la valeur maximale pour les variables `dipl_aucun` et `dipl_sup`.

```{r}
nom_commune_max <- function(valeurs, communes) {
    communes[valeurs == max(valeurs)]
}

rp2018 %>%
    group_by(region) %>%
    summarise(
        across(
            c(dipl_aucun, dipl_sup),
            nom_commune_max,
            commune
        )
    )
```

Réécrire ce code en utilisant une fonction anonyme, avec la syntaxe de votre choix (classique, formule ou compacte).

::: {.solution-exo}
```{r eval=FALSE}
# Classique
rp2018 %>%
    group_by(region) %>%
    summarise(
        across(
            c(dipl_aucun, dipl_sup),
            function(valeurs, communes) { communes[valeurs == max(valeurs)] },
            commune
        )
    )
# Formule
rp2018 %>%
    group_by(region) %>%
    summarise(
        across(
            c(dipl_aucun, dipl_sup),
            ~ .y[.x == max(.x)],
            commune
        )
    )
# Compacte
rp2018 %>%
    group_by(region) %>%
    summarise(
        across(
            c(dipl_aucun, dipl_sup),
            \(valeurs, communes) communes[valeurs == max(valeurs)],
            commune
        )
    )
```
:::

À l'aide d'une fonction anonyme supplémentaire, modifier le code pour qu'il retourne également, pour les mêmes variables, le nom des communes avec les valeurs minimales.

::: {.solution-exo}
```{r eval=FALSE}
# Formule
rp2018 %>%
    group_by(region) %>%
    summarise(
        across(
            c(dipl_aucun, dipl_sup),
            list(
                max = ~ .y[.x == max(.x)],
                min = ~ .y[.x == min(.x)]
            ),
            commune
        )
    )
# Compacte
rp2018 %>%
    group_by(region) %>%
    summarise(
        across(
            c(dipl_aucun, dipl_sup),
            list(
                max = \(valeurs, communes) communes[valeurs == max(valeurs)],
                min = \(valeurs, communes) communes[valeurs == min(valeurs)]
            ),
            commune
        )
    ) %>% View()
```
:::


### `rowwise()` et `c_across()`

**Exercice 4.1**

On repart du code final de l'exercice 2.3, qui recodait une série de variables de `hdv2003` en valeurs `TRUE`/`FALSE` dans de nouvelles variables avec le suffixe `"_true"`.

```{r}
detecte_oui <- function(v) {
    v == "Oui"
}
hdv2003 <- hdv2003 %>%
    mutate(
        across(
            hard.rock:sport,
            detecte_oui,
            .names = "{.col}_true"
        )
    )
```

Calculer le plus simplement possible une nouvelle variable `total` qui contient, pour chaque ligne, le nombre de valeurs `TRUE` des deux variables `cinema_true` et `sport_true` (si une ligne contient `TRUE` pour ces deux variables, `total` doit valoir 2, etc.)

::: {.solution-exo}
```{r eval=FALSE}
hdv2003 %>%
    mutate(total = cuisine_true + sport_true)
```
:::

Recalculer la variable `total` pour qu'elle contienne le nombre de `TRUE` par ligne pour les variables `bricol_true`, `cinema_true` et `sport_true`.

::: {.solution-exo}
```{r eval=FALSE}
hdv2003 %>%
    rowwise() %>%
    mutate(total = sum(cuisine_true, sport_true, bricol_true))
```
:::

Recalculer la variable `total` pour qu'elle contienne le nombre de `TRUE` par ligne pour toutes les variables se terminant par `"_true"`.

::: {.solution-exo}
```{r eval=FALSE}
hdv2003 %>%
    rowwise() %>%
    mutate(total = sum(c_across(ends_with("_true"))))
```
:::


Reprendre le code précédent pour qu'il puisse s'appliquer directement sur les variables `hard.rock`...`sport`, sans passer par le recodage en `TRUE`/`FALSE`. 

::: {.solution-exo}

```{r eval=FALSE}
count_oui <- function(v) {
    sum(v == "Oui")
}

hdv2003 %>%
    rowwise() %>%
    mutate(
        total = count_oui(c_across(hard.rock:sport))
    )
```
:::


**Exercice 4.2**

Dans le jeu de données `starwars`, la colonne `films` contient la liste des films dans lesquels apparaissent les différents personnages. Cette colonne a une forme un peu particulière puisqu'il s'agit d'une "colonne-liste" : les éléments de cette colonne sont eux-mêmes des listes.

```{r}
head(starwars$films, 3)
```

On essaye de calculer le nombre de films pour chaque personnage avec le code suivant. Est-ce que ça fonctionne ? Pourquoi ?

```{r eval=FALSE}
starwars %>%
    mutate(n_films = length(films))
```

Trouver une manière d'obtenir le résultat attendu.

::: {.solution-exo}
```{r eval=FALSE}
starwars %>%
    rowwise() %>%
    mutate(n_films = length(films))
```
:::