Les nombres en R : numeric, integer et fonctions mathématiques

Numeric et integer : les deux types de nombres de R

R stocke les nombres de deux façons. Numeric (stocké comme un flottant double précision) est le type par défaut - chaque nombre que tu tapes est un double, sauf indication contraire. Integer est un type d'entier exact distinct, que tu demandes avec le suffixe L :

x <- 3.14
n <- 42L

cat(typeof(x), typeof(n), "\n")
cat(class(x), class(n), "\n")

En pratique tu n'as presque jamais à t'en soucier : R convertit silencieusement entre les deux, et is.numeric() vaut TRUE pour les deux (voir les types de données pour le système de types complet). Le seul endroit où la distinction se voit, c'est la division - / renvoie toujours un double, même entre deux entiers :

cat(7L / 2L, "\n")
cat(typeof(7L / 2L), "\n")

Les entiers apparaissent surtout en sortie des fonctions de comptage (length(), seq_len(), nrow()) et comme valeurs d'indice. Quand tu as besoin d'une division entière, R a un opérateur dédié - traité plus bas.

La famille des arrondis

R te donne cinq façons de rogner un nombre, chacune avec un sens distinct :

cat(round(3.14159, 2), "\n")
cat(floor(2.7), "\n")
cat(ceiling(2.1), "\n")
cat(trunc(-2.7), "\n")
cat(signif(123456, 2), "\n")

• round(x, digits) - à un nombre de décimales (0 par défaut).
• floor(x) - vers le bas jusqu'à l'entier le plus proche, toujours vers moins l'infini.
• ceiling(x) - vers le haut, toujours vers plus l'infini.
• trunc(x) - coupe les décimales, toujours vers zéro. Note la différence sur les négatifs : trunc(-2.7) vaut -2, mais floor(-2.7) vaut -3.
• signif(x, digits) - à un nombre de chiffres significatifs, pas de décimales : signif(123456, 2) vaut 120000.

Et une surprise célèbre : round() utilise l'arrondi au pair le plus proche (arrondi du banquier) sur les demis exacts, conformément à la norme IEEE 754 :

cat(round(0.5), round(1.5), round(2.5), round(3.5), "\n")

Ça affiche 0 2 2 4 - chaque demi est arrondi vers le nombre pair le plus proche. Ce n'est pas un bug ; ça évite un biais systématique vers le haut quand tu sommes beaucoup de valeurs arrondies. Si un rapport a besoin de l'arrondi scolaire, ajoute un tout petit décalage ou formate à la couche de présentation.

Les fonctions mathématiques du quotidien

Les bases marchent exactement comme tu l'imagines :

cat(sqrt(16), "\n")
cat(abs(-7.5), "\n")
cat(2^10, "\n")
cat(round(exp(1), 6), "\n")

sqrt() est la racine carrée, abs() la valeur absolue, ^ l'exponentiation, et exp(x) c'est e puissance x - donc exp(1) est le nombre d'Euler, environ 2,718282.

La fonction qui fait trébucher tout le monde, c'est log(). En R, log() est le logarithme naturel (base e), pas le logarithme en base 10 :

cat(log(100), "\n")
cat(log10(100), "\n")
cat(log2(8), "\n")
cat(log(8, base = 2), "\n")

La première ligne affiche à peu près 4.60517 - pas le 2 qu'attend un lecteur habitué à la base 10. Passe par log10() et log2() quand tu veux ces bases, ou fournis base = explicitement. (Cette convention est standard en statistique, où le logarithme naturel est le choix par défaut.)

Modulo %% et division entière %/%

Deux opérateurs couvrent l'arithmétique du reste :

cat(17 %% 5, "\n")
cat(17 %/% 5, "\n")

%% est le modulo (le reste) : 17 divisé par 5 fait 3 reste 2. %/% est la division entière : combien de 5 entiers tiennent dans 17. Ensemble ils vérifient x == (x %/% y) * y + (x %% y).

L'usage classique de %% est le test de divisibilité :

n <- 12
cat(n %% 2 == 0, "\n")
cat(n %% 5 == 0, "\n")

Une subtilité avec les nombres négatifs : le %% de R prend le signe du diviseur (comme Python, contrairement à C) :

cat(-7 %% 3, "\n")

C'est 2, pas -1 - R répond « qu'est-ce que j'ajoute à un multiple de 3 pour atteindre -7 ? », ce qui garde les résultats dans 0..2 pour un diviseur positif. Pratique pour faire boucler des indices ; surprenant si tu viens de C ou de Java.

Valeurs spéciales : Inf, -Inf et NaN

Les nombres de R suivent la norme IEEE 754, donc certaines opérations produisent des valeurs spéciales plutôt que des erreurs :

cat(1 / 0, "\n")
cat(-1 / 0, "\n")
cat(0 / 0, "\n")

1/0 donne Inf (l'infini), -1/0 donne -Inf, et 0/0 - une quantité réellement indéfinie - donne NaN, « not a number ». La distinction compte : Inf est une réponse (« plus grand que tout »), NaN est l'absence de réponse. Tu les testes avec des fonctions dédiées, parce que == NaN ne marche jamais :

cat(is.infinite(1 / 0), "\n")
cat(is.nan(0 / 0), "\n")
cat(is.na(0 / 0), "\n")

Note la dernière ligne : NaN compte aussi comme NA, donc is.na() l'attrape - une raison de plus pour laquelle is.na() est le test standard « cette valeur est-elle inutilisable ? » (plus de détails dans les valeurs manquantes).

R lit et écrit aussi la notation scientifique nativement - 2.5e3 vaut 2500, et les nombres très petits ou très grands s'affichent en notation e par défaut :

cat(2.5e3, "\n")
cat(1e-4, "\n")
cat(format(1e-4, scientific = FALSE), "\n")

Utilise format(x, scientific = FALSE) (ou l'option scipen) quand un rapport a besoin de décimaux en clair.

La surprise de la virgule flottante

Tous les langages qui stockent les décimaux en binaire partagent celle-ci, et R ne fait pas exception :

cat(0.1 + 0.2 == 0.3, "\n")
print(0.1 + 0.2, digits = 17)

FALSE - parce que 0.1 + 0.2 vaut en réalité 0.30000000000000004. Ni 0,1 ni 0,2 n'ont de représentation binaire exacte, et les minuscules erreurs s'accumulent. L'affichage par défaut de R masque ça en montrant 7 chiffres significatifs, c'est pourquoi le problème semble invisible jusqu'à ce qu'une comparaison == échoue.

La règle : ne compare jamais des décimaux calculés avec ==. Utilise all.equal(), qui compare à une tolérance raisonnable :

cat(isTRUE(all.equal(0.1 + 0.2, 0.3)), "\n")

Enveloppe-le dans isTRUE() parce que all.equal() renvoie une description de la différence (et non FALSE) quand les valeurs diffèrent. Pour du travail sur des entiers où l'exactitude compte, les integers sont exacts jusqu'à environ 2,1 milliards - une raison de plus pour laquelle le code de comptage utilise le type integer.

Ce que tu retiens

• Tout nombre tapé est un double ; 42L crée un integer, et / renvoie un double dans tous les cas.
• round() arrondit au pair le plus proche ; floor/ceiling/trunc/signif rognent chacun différemment - sache lequel tu veux.
• log() est le logarithme naturel ; utilise log10(), log2() ou base = pour les autres bases.
• %% donne le reste (le signe suit le diviseur), %/% le quotient entier.
• 1/0 vaut Inf, 0/0 vaut NaN, et 0.1 + 0.2 != 0.3 - compare les décimaux avec all.equal(), jamais avec ==.

Prochaine étape : l'autre moitié des données du quotidien - les chaînes de caractères, et les fonctions que R te donne pour les construire, les formater et les fouiller.