Matrici in R: matrix(), cbind, rbind e calcolo matriciale

Una matrice è un vettore con dimensioni

Una matrice in R è un rettangolo di valori, con righe e colonne, in cui ogni cella contiene lo stesso tipo, di solito numeri. Sotto il cofano è letteralmente un vettore con un attributo dim attaccato sopra, e questo spiega gran parte del suo comportamento: un solo tipo ovunque, calcoli vettorizzati ovunque.

Ne costruisci una rimodellando un vettore con matrix():

m <- matrix(1:6, nrow = 2)
print(m)
print(dim(m))
print(nrow(m))
print(ncol(m))

Sei valori, due righe: R capisce da solo che servono tre colonne. dim() riporta entrambe le dimensioni insieme come 2 3; nrow() e ncol() le danno separatamente.

Guarda bene la matrice stampata: i valori scorrono 1 2 lungo la prima colonna, poi 3 4 lungo la successiva. Di default R riempie le matrici colonna per colonna. Se i tuoi dati si leggono riga per riga, che è il modo in cui di solito li scriviamo, dillo con byrow = TRUE:

m <- matrix(1:6, nrow = 2, byrow = TRUE)
print(m)

Ora la prima riga è 1 2 3. Dimenticare byrow = TRUE non dà errore: ti restituisce in silenzio una disposizione degli stessi numeri che sembra trasposta, quindi prendi l'abitudine di controllare il layout stampato ogni volta che costruisci una matrice da valori grezzi.

Indicizzazione: m[row, column]

L'indicizzazione delle matrici usa due posizioni dentro una sola coppia di parentesi quadre, la riga prima della virgola e la colonna dopo, entrambe contando da 1:

m <- matrix(1:6, nrow = 2, byrow = TRUE)
print(m)

print(m[1, 2])
print(m[1, ])
print(m[, 2])

Lasciare vuota una posizione significa "tutte": m[1, ] è l'intera prima riga, m[, 2] l'intera seconda colonna. Nota che entrambe tornano come semplici vettori: R elimina la dimensione che si è ridotta a 1. È comodo in modo interattivo e una trappola nel codice, perché una funzione che si aspetta una matrice si blocca sul vettore. Chiedi a R di mantenere la forma con drop = FALSE:

m <- matrix(1:6, nrow = 2, byrow = TRUE)

row1 <- m[1, , drop = FALSE]
print(row1)
print(dim(row1))

Ora dim() riporta 1 3: è ancora una matrice. Ogni volta che estrai una singola riga o colonna dentro una funzione, scrivi drop = FALSE; il bug che previene (codice che funziona su dati larghi e si rompe su dati con una sola colonna) è di quelli terribili da scovare.

Anche le maschere logiche funzionano: m[m > 3] restituisce tutte le celle maggiori di 3, come vettore.

Costruire con cbind() e rbind()

Invece di rimodellare un unico vettore lungo, puoi assemblare una matrice a pezzi: cbind() unisce i vettori come colonne, rbind() come righe. Le stesse funzioni estendono anche una matrice esistente:

heights <- c(170, 182, 165)
weights <- c(65, 80, 58)

people <- cbind(heights, weights)
print(people)

people <- rbind(people, c(175, 72))
print(people)

I nomi viaggiano con i vettori: cbind() ha usato automaticamente heights e weights come nomi di colonna, e questo mantiene leggibile la matrice stampata. Entrambe le funzioni pretendono che le lunghezze combacino (con il riciclo per i valori di lunghezza 1); unire un vettore di lunghezza 3 a una matrice di 4 righe produce un avviso.

I nomi di colonna e di riga si possono anche impostare direttamente con colnames(m) <- ... e rownames(m) <- ..., dopodiché puoi indicizzare per nome: people[, "weights"].

* elemento per elemento contro la vera moltiplicazione matriciale %*%

Ecco la distinzione che conta di più in tutto l'articolo. R ha due operatori di moltiplicazione per le matrici, e calcolano cose del tutto diverse:

a <- matrix(1:4, nrow = 2)
print(a)

print(a * a)
print(a %*% a)

• a * a è elemento per elemento: ogni cella moltiplicata per la cella corrispondente. 1 2 3 4 diventano 1 4 9 16, disposti nella stessa forma. È semplice aritmetica vettorizzata, lo stesso * che usi sui vettori.
• a %*% a è la moltiplicazione matriciale dell'algebra lineare: ogni cella del risultato è una riga della prima matrice per una colonna della seconda, sommate. Lo stesso input dà 7 10 15 22: numeri completamente diversi.

Esegui il frammento e confronta i due output fianco a fianco; vederli diversi su input identici è ciò che fissa la distinzione. Se scrivi * dove la matematica richiede %*%, R non ti avvisa (per le matrici quadrate le forme sono compatibili in entrambi i casi): ottieni solo numeri sbagliati. Nel codice statistico (matrici di covarianza, algebra dei modelli lineari) è uno dei classici bug silenziosi.

t() traspone, cioè scambia righe e colonne, e compare di continuo accanto a %*% perché la moltiplicazione matriciale richiede che le dimensioni interne coincidano:

a <- matrix(1:4, nrow = 2)
print(t(a))
print(t(a) %*% a)

Per completezza: solve(m) inverte una matrice, e %*% con un vettore lo tratta come una matrice di una colonna. Per la maggior parte del lavoro sui dati non serve andare più a fondo.

Riepiloghi per righe e colonne

Sommare o fare la media lungo righe e colonne è così comune che R offre funzioni dedicate e veloci:

m <- matrix(1:6, nrow = 2, byrow = TRUE)
print(m)

print(rowSums(m))
print(colSums(m))
print(rowMeans(m))
print(colMeans(m))

rowSums() riduce ogni riga a un numero (6 15 qui), colSums() ogni colonna (5 7 9), e le varianti Means calcolano la media. Preferiscile ai cicli scritti a mano e perfino ad apply(m, 1, sum): sono più chiare e più veloci. Per i riepiloghi che queste quattro non coprono (per esempio il massimo di ogni colonna), la famiglia apply è lo strumento generale: apply(m, 2, max).

Matrice o data frame?

Sono entrambi rettangolari, quindi quale scegli?

• Matrice: ogni cella dello stesso tipo, e i calcoli contano. Calcolo numerico, algebra lineare, calcolo di distanze, griglie simili a immagini. Le matrici sono più leggere e le loro operazioni più veloci proprio grazie alla garanzia di un solo tipo.
• Data frame: colonne di tipi diversi, con nomi accanto a età accanto a flag logici. Sono i dati tabellari del mondo reale, ed è quello che si aspettano quasi tutte le funzioni di analisi dei dati.

Una buona regola: se lo apriresti naturalmente in un foglio di calcolo con colonne con nome e di tipo misto, è un data frame. Se è una griglia di numeri su cui vuoi fare algebra, è una matrice. Convertire dall'uno all'altro è facile (as.matrix(), as.data.frame()), ma as.matrix() su un data frame con anche una sola colonna di testo converte tutto in carattere, quindi converti solo le colonne numeriche.

Cosa ti porti a casa

• Una matrice è un vettore con dimensioni: un solo tipo ovunque, costruita con matrix(data, nrow, ncol), e si riempie colonna per colonna a meno che tu non passi byrow = TRUE.
• Indicizza con m[row, col]; una posizione vuota significa "tutte"; aggiungi drop = FALSE quando estrai singole righe o colonne nel codice.
• cbind() e rbind() assemblano matrici a partire da vettori o estendono quelle esistenti.
• * è elemento per elemento, %*% è la vera moltiplicazione matriciale: stessi input, risposte diverse, nessun avviso.
• rowSums() / colSums() / rowMeans() / colMeans() gestiscono i riepiloghi di tutti i giorni.

Prossimo passo: i factor, come R rappresenta i dati categorici e le trappole che si portano dietro.