0Pricing
R Academy · Lección

Aritmética y operaciones con matrices

Realice multiplicaciones elemento a elemento y matriciales, sumas y restas.

Aritmética y operaciones con matrices es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

Operaciones elemento a elemento frente a operaciones matriciales

R distingue entre operaciones elemento a elemento (que usan +, -, *, /) y verdaderas operaciones matriciales (que usan %*%). Comprender esta diferencia es fundamental para realizar correctamente álgebra lineal.

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)

Suma y resta elemento a elemento

+ y - entre dos matrices con las mismas dimensiones suman o restan los elementos correspondientes. Son operaciones puramente elemento a 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)

División y multiplicación elemento a elemento

De forma similar, * y / entre matrices del mismo tamaño operan elemento por elemento. Esto resulta útil para escalar, normalizar o combinar matrices elemento a 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)

Operaciones escalares sobre matrices

Puede aplicar una operación con un escalar (un solo número) a todos los elementos de una matriz mediante los operadores aritméticos habituales. El escalar se recicla para ajustarse a las dimensiones de la matriz.

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)

Multiplicación matricial verdadera %*%

A %*% B realiza una multiplicación matricial de álgebra lineal. Para que funcione, el número de columnas de A debe ser igual al número de filas de B. El resultado tiene dimensiones (filas de A) x (columnas de 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() y colSums()

rowSums(m) calcula la suma de cada fila; colSums(m) calcula la suma de cada columna. Ambas funciones devuelven vectores con nombre si la matriz tiene nombres de dimensión.

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() y colMeans()

rowMeans(m) y colMeans(m) devuelven el promedio de cada fila y columna, respectivamente. Son más rápidas que aplicar mean() con apply() para esta tarea habitual.

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))

Operaciones de comparación en matrices

Los operadores de comparación (==, >, <=, etc.) aplicados a matrices devuelven una matriz lógica con las mismas dimensiones. Después puede usar esta máscara para seleccionar elementos o contarlos.

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() para operaciones personalizadas sobre filas o columnas

apply(m, MARGIN, FUN) aplica una función a las filas (MARGIN=1) o a las columnas (MARGIN=2). Úsela cuando necesite una agregación personalizada que vaya más allá de 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)), '
')

Difundir un vector por las filas

Cuando suma o multiplica un vector por una matriz, R recicla el vector — lo repite cíclicamente para ajustarlo a la longitud de la matriz. El reciclaje se realiza columna por columna, lo que puede producir resultados inesperados si desea operar por filas.

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, '*'))

Resumen de operaciones aritméticas

Funciones clave para operar con matrices en R:

  • +, -, *, / — aritmética elemento a elemento
  • %*% — multiplicación matricial (álgebra lineal)
  • rowSums(), colSums() — totales por fila o columna
  • rowMeans(), colMeans() — promedios por fila o columna
  • apply(m, 1, fn) / apply(m, 2, fn) — agregación personalizada por filas o columnas
  • sweep() — operaciones por filas o columnas con un vector
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), '
')

Comprobación rápida

¿Qué calcula A * B cuando A y B son matrices 2x2 en R?

Repaso: aritmética matricial

¡Buen trabajo! Estas son las ideas clave de la lección:

  • +, -, *, / sobre matrices son operaciones elemento a elemento
  • %*% es una verdadera multiplicación matricial (filas × columnas)
  • rowSums(), colSums(), rowMeans(), colMeans() realizan agregaciones sobre filas o columnas
  • Los operadores de comparación devuelven una matriz lógica con la misma forma
  • apply(m, 1, fn) aplica una función por filas; apply(m, 2, fn), por columnas
  • Use sweep() para escalar filas o columnas de forma vectorizada
# 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)

Preguntas frecuentes

¿La lección «Aritmética y operaciones con matrices» es gratis?

Sí — el texto completo de «Aritmética y operaciones con matrices» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Aritmética y operaciones con matrices»?

Realice multiplicaciones elemento a elemento y matriciales, sumas y restas. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Aritmética y operaciones con matrices»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Creación de matrices con matrix()
  2. Indexación y subconfiguración de matrices
  3. Aritmética y operaciones con matrices
  4. Transposición y cambio de forma de matrices
← Volver a R Academy