Les opérateurs en R : arithmétiques, de comparaison, logiques, %in% et %%

Les opérateurs que R te donne

Les opérateurs de R se répartissent en quatre groupes de travail : arithmétiques (+ - * / ^ %% %/%), de comparaison (== != < <= > >=), logiques (& | && || ! xor), et le test d'appartenance %in%. Deux choses les distinguent de la plupart des langages : presque tous sont vectorisés - ils opèrent sur des vecteurs entiers d'un coup, élément par élément - et R a deux opérateurs ET et deux opérateurs OU qui ne sont pas interchangeables. Cette page les couvre tous, plus les pièges de priorité qui produisent des réponses silencieusement fausses.

Arithmétique : +, -, *, /, ^, %% et %/%

Les cinq premiers font ce que tu attends. Les deux entourés de pourcents - %% (modulo, le reste) et %/% (division entière, le quotient) - sont ceux que les gens cherchent :

a <- 17
b <- 5

print(a + b)    # 22
print(a - b)    # 12
print(a * b)    # 85
print(a / b)    # 3.4
print(a ^ b)    # 1419857
print(a %% b)   # 2  - the remainder of 17 / 5
print(a %/% b)  # 3  - how many whole times 5 fits into 17

Note que / fait toujours une division en virgule flottante - 17 / 5 vaut 3.4, jamais 3. Si tu veux la partie entière, c'est exactement le rôle de %/%.

Le travail quotidien de %%, c'est la divisibilité. Un nombre est pair quand la division par 2 ne laisse pas de reste :

n <- 42
print(n %% 2 == 0)   # TRUE - even

print(-7 %% 3)       # 2, not -1

Cette seconde ligne mérite une pause : avec un opérande négatif, le %% de R renvoie un résultat portant le signe du diviseur (-7 %% 3 vaut 2, parce que -7 = -3 * 3 + 2). Certains langages font l'inverse ; si tu portes du code, vérifie.

Les opérateurs de comparaison sont vectorisés

==, !=, <, <=, >, >= comparent élément par élément et renvoient un vecteur logique, pas une réponse unique :

scores <- c(45, 72, 88, 60)

print(scores >= 60)           # FALSE TRUE TRUE TRUE
print(scores[scores >= 60])   # 72 88 60

C'est le moteur de presque tout le filtrage en R - tu compares un vecteur entier à une valeur, tu obtiens un masque logique, et tu utilises le masque pour extraire. Une mise en garde avec == sur les décimaux : les nombres en virgule flottante sont stockés de façon approchée, donc 0.1 + 0.2 == 0.3 vaut FALSE. Pour les comparaisons décimales, préfère all.equal() ou vérifie abs(x - y) < 1e-9.

Opérateurs logiques : & ou && (la confusion classique)

R a deux opérateurs ET et deux opérateurs OU, et choisir le mauvais est un rite de passage.

& et | sont vectorisés. Ils combinent deux vecteurs logiques élément par élément :

sunny <- c(TRUE, TRUE, FALSE, FALSE)
warm  <- c(TRUE, FALSE, TRUE, FALSE)

print(sunny & warm)   # TRUE FALSE FALSE FALSE
print(sunny | warm)   # TRUE TRUE TRUE FALSE
print(!sunny)         # FALSE FALSE TRUE TRUE

Utilise-les dès que tu construis un filtre sur des données : df[df$age > 30 & df$city == "Lisbon", ].

&& et || sont scalaires et court-circuitent. Ils prennent des valeurs uniques, renvoient un seul TRUE/FALSE, et sautent entièrement le second opérande si le premier tranche déjà la réponse :

x <- 8

print(x > 0 && x %% 2 == 0)         # TRUE - both checked
print(x < 0 && stop("never runs"))  # FALSE - stop() is never evaluated

Cette seconde ligne illustre le court-circuit : comme x < 0 vaut FALSE, R n'évalue jamais l'appel à stop(). C'est exactement pourquoi && a sa place dans les conditions if() - tu peux écrire if (!is.na(x) && x > 10) et la partie x > 10 est sautée sans risque quand x vaut NA.

La règle empirique : &/| pour les vecteurs et le filtrage de données, &&/|| pour les conditions if(). Et depuis R 4.3, c'est appliqué fermement : donner à && ou || un vecteur de longueur supérieure à 1 est une erreur (les anciennes versions de R n'utilisaient silencieusement que le premier élément, ce qui a masqué de vrais bugs pendant des années).

xor(a, b) complète l'ensemble - TRUE quand exactement l'un des deux est TRUE :

print(xor(TRUE, FALSE))  # TRUE
print(xor(TRUE, TRUE))   # FALSE

%in% : tester l'appartenance

x %in% table demande, pour chaque élément de x, « celui-ci apparaît-il quelque part dans table ? ». C'est l'un des opérateurs les plus utilisés dans du vrai code R :

basket <- c("apple", "banana", "cherry")

print("banana" %in% basket)   # TRUE
print("mango" %in% basket)    # FALSE

wanted <- c("cherry", "mango", "apple")
print(wanted %in% basket)     # TRUE FALSE TRUE

Le côté testé peut être un vecteur entier, ce qui fait de %in% l'outil naturel pour filtrer des lignes selon un ensemble de valeurs autorisées.

Il bat aussi l'alternative que tu écrirais sinon - une chaîne de == collés avec des | :

day <- "sat"

print(day == "sat" | day == "sun")   # works, but scales badly
print(day %in% c("sat", "sun"))      # same answer, stays readable

Avec cinq valeurs autorisées, la chaîne de == devient un mur de répétitions ; la version %in% se contente d'allonger le vecteur. Il y a un second avantage, plus subtil - %in% ne renvoie jamais NA :

print(NA == 1)             # NA - comparison with a missing value is unknown
print(NA %in% c(1, 2, 3))  # FALSE - %in% gives a definite answer

NA == 1 vaut NA parce que R ne peut pas savoir si une valeur inconnue est égale à 1 - un comportement traité en profondeur dans les valeurs manquantes. Ce NA empoisonne ensuite tout if() qu'il atteint. %in% contourne tout le problème en répondant toujours TRUE ou FALSE, ce qui en fait le choix le plus sûr pour des conditions sur des données potentiellement manquantes.

Pièges de priorité

Deux pièges de priorité des opérateurs expliquent une part disproportionnée des moments « R est cassé ». D'abord, ^ a une priorité plus forte que le moins unaire :

print(-2^2)     # -4  - parsed as -(2^2)
print((-2)^2)   #  4  - the square of negative two

Ensuite, le deux-points a une priorité plus forte que l'arithmétique binaire :

n <- 5

print(1:n - 1)     # 0 1 2 3 4  - parsed as (1:n) - 1
print(1:(n - 1))   # 1 2 3 4    - probably what you meant

Dans le doute, ajoute des parenthèses. Elles ne coûtent rien et chaque lecteur (y compris toi dans le futur) les interprète comme l'interpréteur.

$ et [ ] : les opérateurs d'accès

Tu verras aussi constamment $, [ ] et [[ ]] - techniquement des opérateurs eux aussi, utilisés pour extraire des valeurs de structures plutôt que pour calculer :

person <- list(name = "Rosa", age = 30)

print(person$name)     # by name, with $
print(person[["age"]]) # by name, with [[ ]]

Ils sont traités en détail dans les pages sur les vecteurs, les listes et les data frames - ici il suffit de les reconnaître comme membres de la même famille d'opérateurs.

Ce que tu retiens

• %% donne le reste, %/% le quotient entier ; x %% 2 == 0 teste la parité.
• Les comparaisons sont vectorisées - elles renvoient un vecteur logique avec lequel tu peux filtrer.
• &/| combinent des vecteurs élément par élément ; &&/|| sont pour les valeurs uniques dans if() et court-circuitent. Depuis R 4.3, && sur un vecteur plus long est une erreur.
• x %in% table remplace les == enchaînés et ne renvoie jamais NA.
• -2^2 vaut -4 et 1:n - 1 commence à 0 - mets des parenthèses dans le doute.

Prochaine étape : mettre ces opérateurs au travail dans if, else et ifelse() - les instructions conditionnelles de R.