0Pricing
R Academy · Lezione

Aritmetica e operazioni sulle matrici

Esegua moltiplicazioni elemento per elemento e matriciali, addizioni e sottrazioni.

Aritmetica e operazioni sulle matrici è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Operazioni elemento per elemento e operazioni tra matrici

R distingue tra operazioni elemento per elemento (che usano +, -, *, /) e vere operazioni tra matrici (che usano %*%). Comprendere questa differenza è fondamentale per eseguire correttamente l'algebra lineare.

A <- matrix(c(1,2,3,4), nrow = 2)
B <- matrix(c(5,6,7,8), nrow = 2)
cat('A:
'); print(A)
cat('B:
'); print(B)

# Element-wise multiply
cat('A * B (element-wise):
'); print(A * B)
# Matrix multiply
cat('A %*% B (matrix mult):
'); print(A %*% B)

Addizione e sottrazione elemento per elemento

+ e - tra due matrici con le stesse dimensioni sommano o sottraggono gli elementi corrispondenti. Si tratta esclusivamente di operazioni elemento per elemento.

# Monthly revenue vs target (in thousands)
revenue <- matrix(c(120,135,110,98, 145,160,132,115),
                  nrow = 2, byrow = TRUE)
target  <- matrix(c(130,130,130,130, 150,150,150,150),
                  nrow = 2, byrow = TRUE)

deviation <- revenue - target
cat('Revenue vs Target deviation:
')
print(deviation)
cat('Above target?:
')
print(revenue >= target)

Divisione e moltiplicazione elemento per elemento

Analogamente, * e / tra matrici della stessa dimensione operano elemento per elemento. Questo è utile per ridimensionare, normalizzare o combinare matrici elemento per elemento.

# Scale a matrix by another (element-wise)
prices <- matrix(c(10, 20, 15, 25), nrow = 2)
quantities <- matrix(c(5, 3, 8, 2), nrow = 2)

total_cost <- prices * quantities
cat('Total cost per item:
')
print(total_cost)

# Normalise to row maximum
max_prices <- matrix(rep(apply(prices, 1, max), 2), nrow = 2)
norm_prices <- prices / max_prices
cat('Normalised prices:
')
print(norm_prices)

Operazioni scalari sulle matrici

Può applicare un'operazione scalare (su un singolo numero) a ogni elemento di una matrice usando i normali operatori aritmetici. Lo scalare viene riciclato per adattarsi alle dimensioni della matrice.

m <- matrix(c(10, 20, 30, 40, 50, 60), nrow = 2, ncol = 3)
cat('Original:
'); print(m)

cat('m + 5:
');  print(m + 5)
cat('m * 2:
');  print(m * 2)
cat('m / 10:
'); print(m / 10)
cat('m ^ 2:
');  print(m ^ 2)

Vera moltiplicazione tra matrici %*%

A %*% B esegue la moltiplicazione tra matrici dell'algebra lineare. Perché funzioni, il numero di colonne di A deve essere uguale al numero di righe di B. Il risultato ha dimensioni (righe di A) x (colonne di B).

# 2x3 times 3x2 = 2x2
A <- matrix(c(1,2,3, 4,5,6), nrow = 2, byrow = TRUE)
B <- matrix(c(7,8, 9,10, 11,12), nrow = 3, byrow = TRUE)
cat('A (2x3):
'); print(A)
cat('B (3x2):
'); print(B)
cat('A %*% B (2x2):
'); print(A %*% B)

rowSums() e colSums()

rowSums(m) calcola la somma di ogni riga; colSums(m) calcola la somma di ogni colonna. Entrambe restituiscono vettori con nome se la matrice ha nomi per le dimensioni.

sales <- matrix(
  c(120,135,110,98,  145,160,132,115,  88,95,102,78),
  nrow = 3, byrow = TRUE,
  dimnames = list(c('Q1','Q2','Q3'), c('Jan','Feb','Mar','Apr'))
)
cat('Sales matrix:
'); print(sales)
cat('Quarterly totals:', rowSums(sales), '
')
cat('Monthly totals: ', colSums(sales), '
')

rowMeans() e colMeans()

rowMeans(m) e colMeans(m) restituiscono rispettivamente la media di ogni riga e di ogni colonna. Per questa operazione comune sono più veloci di mean() usato con apply().

exam_scores <- matrix(
  c(88,92,75,81, 79,85,90,73, 95,78,82,88),
  nrow = 3, byrow = TRUE,
  dimnames = list(c('Alice','Bob','Carol'), c('Math','Sci','Eng','Hist'))
)
cat('Student averages:
')
print(rowMeans(exam_scores))
cat('Subject averages:
')
print(colMeans(exam_scores))

Operazioni di confronto sulle matrici

Gli operatori di confronto (==, >, <=, ecc.) applicati alle matrici restituiscono una matrice logica con le stesse dimensioni. Può quindi usare questa maschera per selezionare o contare gli elementi.

scores <- matrix(c(88,45,92,61,73,55,84,79), nrow = 2)
cat('Scores:
'); print(scores)

# Which elements pass?
passing_mask <- scores >= 60
cat('Passing mask:
'); print(passing_mask)
cat('Number passing:', sum(passing_mask), '
')
cat('Passing scores:', scores[passing_mask], '
')

apply() per operazioni personalizzate su righe e colonne

apply(m, MARGIN, FUN) applica una funzione alle righe (MARGIN=1) o alle colonne (MARGIN=2). Lo usi quando serve un'aggregazione personalizzata oltre a rowSums/colMeans.

m <- matrix(c(3,1,4,1,5,9,2,6,5,3,5,8), nrow = 3)
cat('Matrix:
'); print(m)

# Max of each row
cat('Row max:  ', apply(m, 1, max), '
')
# Range of each column
cat('Col range:
')
print(apply(m, 2, range))
# Custom: count values > 4 per row
cat('Values > 4 per row:', apply(m, 1, function(x) sum(x > 4)), '
')

Applicare un vettore alle righe

Quando aggiunge o moltiplica un vettore per una matrice, R ricicla il vettore, scorrendolo ciclicamente per adattarlo alla lunghezza della matrice. Il riciclo avviene colonna per colonna, e può produrre risultati imprevisti se desidera operare riga per riga.

m <- matrix(c(10,20,30, 40,50,60), nrow = 2)
cat('Matrix:
'); print(m)

# Add a 3-element vector: R recycles column-by-column
v <- c(1, 2, 3)
cat('m + c(1,2,3):
'); print(m + v)

# For row-wise scaling, use sweep()
row_weights <- c(0.5, 2.0)  # scale row 1 by 0.5, row 2 by 2
cat('Row-wise scaled:
'); print(sweep(m, 1, row_weights, '*'))

Riepilogo delle operazioni aritmetiche

Funzioni chiave per le operazioni sulle matrici in R:

  • +, -, *, / — aritmetica elemento per elemento
  • %*% — moltiplicazione tra matrici (algebra lineare)
  • rowSums(), colSums() — totali per riga o colonna
  • rowMeans(), colMeans() — medie per riga o colonna
  • apply(m, 1, fn) / apply(m, 2, fn) — aggregazione personalizzata per riga o colonna
  • sweep() — operazioni per riga o colonna con un vettore
m <- matrix(c(4,9,16,25), nrow = 2)
cat('Original:
'); print(m)
cat('sqrt (element-wise):
'); print(sqrt(m))
cat('rowSums:', rowSums(m), '
')
cat('colMeans:', colMeans(m), '
')

Verifica rapida

Che cosa calcola A * B quando A e B sono matrici 2x2 in R?

Riepilogo: aritmetica delle matrici

Ottimo lavoro! Ecco i concetti chiave di questa lezione:

  • +, -, *, / sulle matrici operano elemento per elemento
  • %*% è la vera moltiplicazione tra matrici (righe × colonne)
  • rowSums(), colSums(), rowMeans(), colMeans() aggregano i valori per riga o colonna
  • Gli operatori di confronto restituiscono una matrice logica con la stessa forma
  • apply(m, 1, fn) applica una funzione riga per riga; apply(m, 2, fn) colonna per colonna
  • Usi sweep() per ridimensionare vettorialmente righe o colonne
# Final: compute grade curve (add 5 to all scores, cap at 100)
raw <- matrix(c(88,55,92,73,60,45,78,95), nrow = 2)
curved <- pmin(raw + 5, 100)  # pmin applies min element-wise
cat('Raw:
');    print(raw)
cat('Curved:
'); print(curved)

Domande Frequenti

La lezione «Aritmetica e operazioni sulle matrici» è gratuita?

Sì — il testo completo di «Aritmetica e operazioni sulle matrici» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Aritmetica e operazioni sulle matrici»?

Esegua moltiplicazioni elemento per elemento e matriciali, addizioni e sottrazioni. Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Aritmetica e operazioni sulle matrici»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Creazione di matrici con matrix()
  2. Indicizzazione e subset delle matrici
  3. Aritmetica e operazioni sulle matrici
  4. Trasposizione e rimodellazione delle matrici
← Torna a R Academy