Numeri in R: numeric, integer e funzioni matematiche

Numeric e integer: i due tipi di numero di R

R memorizza i numeri in due modi. Numeric (memorizzato come numero in virgola mobile a doppia precisione) è il default: ogni numero che scrivi è un double, a meno che tu non dica altrimenti. Integer è un tipo separato per numeri interi esatti, che richiedi con il suffisso L:

x <- 3.14
n <- 42L

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

Nella pratica raramente devi preoccupartene: R converte dall'uno all'altro in silenzio, e is.numeric() è TRUE per entrambi (vedi tipi di dati per il sistema dei tipi completo). L'unico punto in cui la distinzione si vede è la divisione: / restituisce sempre un double, anche tra due interi:

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

Gli interi compaiono soprattutto come risultato di funzioni di conteggio (length(), seq_len(), nrow()) e come valori di indice. Quando ti serve la divisione intera, R ha un operatore dedicato, che vediamo più avanti.

La famiglia degli arrotondamenti

R ti dà cinque modi per accorciare un numero, ognuno con un significato preciso:

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): a un certo numero di cifre decimali (0 di default).
• floor(x): per difetto all'intero più vicino, sempre verso meno infinito.
• ceiling(x): per eccesso, sempre verso più infinito.
• trunc(x): taglia i decimali, sempre verso zero. Nota la differenza sui negativi: trunc(-2.7) è -2, ma floor(-2.7) è -3.
• signif(x, digits): a un certo numero di cifre significative, non di cifre decimali: signif(123456, 2) è 120000.

E una sorpresa famosa: sulle metà esatte round() usa l'arrotondamento half to even (arrotondamento del banchiere), secondo lo standard IEEE 754:

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

Stampa 0 2 2 4: ogni metà viene arrotondata al numero pari più vicino. Non è un bug; evita una distorsione sistematica verso l'alto quando sommi tanti valori arrotondati. Se un report ha bisogno dell'arrotondamento scolastico, aggiungi una piccola spinta o formatta i numeri al momento della presentazione.

Funzioni matematiche di tutti i giorni

Le basi funzionano esattamente come ti aspetti:

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

sqrt() è la radice quadrata, abs() il valore assoluto, ^ l'elevamento a potenza, e exp(x) è e elevato alla x, quindi exp(1) è il numero di Eulero, circa 2.718282.

L'unica funzione che fa inciampare è log(). In R, log() è il logaritmo naturale (base e), non in base 10:

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

La prima riga stampa circa 4.60517, non il 2 che si aspetta chi ragiona in base 10. Usa log10() e log2() quando intendi quelle basi, oppure passa base = in modo esplicito. (Questa convenzione è standard in statistica, dove il logaritmo naturale è quello predefinito.)

Modulo %% e divisione intera %/%

Due operatori coprono l'aritmetica dei resti:

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

%% è il modulo (resto): 17 diviso 5 fa 3 con resto 2. %/% è la divisione intera: quanti 5 interi stanno in 17. Insieme soddisfano x == (x %/% y) * y + (x %% y).

L'uso classico di %% è verificare la divisibilità:

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

Una sottigliezza con i numeri negativi: il %% di R prende il segno del divisore (come Python, a differenza di C):

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

Il risultato è 2, non -1: R risponde alla domanda "cosa aggiungo a un multiplo di 3 per arrivare a -7?", e così i risultati restano in 0..2 per un divisore positivo. Comodo per far ricominciare gli indici da capo; sorprendente se vieni da C o Java.

Valori speciali: Inf, -Inf e NaN

I numeri di R seguono lo standard IEEE 754, quindi alcune operazioni producono valori speciali invece di errori:

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

1/0 è Inf (infinito), -1/0 è -Inf, e 0/0, una quantità davvero indefinita, è NaN, "not a number". La distinzione conta: Inf è una risposta ("più grande di qualsiasi cosa"), NaN è l'assenza di una risposta. Li verifichi con funzioni dedicate, perché == NaN non funziona mai:

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

Nota l'ultima riga: anche NaN conta come NA, quindi is.na() lo intercetta, un motivo in più per cui is.na() è il controllo standard per "questo valore è inutilizzabile?" (approfondimenti in valori mancanti).

R legge e scrive anche la notazione scientifica in modo nativo: 2.5e3 è 2500, e i numeri molto piccoli o molto grandi vengono stampati in notazione e di default:

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

Usa format(x, scientific = FALSE) (o l'opzione scipen) quando un report ha bisogno di decimali normali.

La sorpresa della virgola mobile

Tutti i linguaggi che memorizzano i decimali in binario condividono questa, e R non fa eccezione:

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

FALSE, perché 0.1 + 0.2 in realtà vale 0.30000000000000004. Né 0.1 né 0.2 hanno una rappresentazione binaria esatta, e i piccoli errori si accumulano. La stampa predefinita di R lo nasconde mostrando 7 cifre significative, ed è per questo che il problema sembra invisibile finché un confronto con == non fallisce.

La regola: non confrontare mai decimali calcolati con ==. Usa all.equal(), che confronta entro una tolleranza sensata:

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

Avvolgilo in isTRUE() perché, quando i valori differiscono, all.equal() restituisce una descrizione della differenza (non FALSE). Per il lavoro con numeri interi in cui l'esattezza conta, gli integer sono esatti fino a circa 2.1 miliardi: un altro motivo per cui il codice di conteggio usa il tipo integer.

Cosa ti porti a casa

• Ogni numero che scrivi è un double; 42L crea un integer, e / restituisce comunque un double.
• round() arrotonda le metà al pari; floor/ceiling/trunc/signif accorciano ciascuno in modo diverso: sappi quale intendi.
• log() è il logaritmo naturale; usa log10(), log2() o base = per le altre basi.
• %% dà il resto (il segno segue il divisore), %/% il quoziente intero.
• 1/0 è Inf, 0/0 è NaN, e 0.1 + 0.2 != 0.3: confronta i decimali con all.equal(), mai con ==.

Prossimo passo: l'altra metà dei dati di tutti i giorni, le stringhe, e le funzioni che R ti dà per costruirle, formattarle e cercarci dentro.