Álgebra Básica para Programación - 61. Operaciones básicas con matrices

61.1 Introducción

Una vez que una matriz organiza datos, podemos aplicar operaciones para obtener nuevas matrices o resultados numéricos.

Operaciones frecuentes:
suma, resta, multiplicación por escalar, transposición y producto de matrices.

Estas operaciones aparecen en gráficos, videojuegos, ciencia de datos e inteligencia artificial.

61.2 Matrices del mismo tamaño

Para sumar o restar matrices, ambas deben tener la misma cantidad de filas y columnas.

A es de 2 x 3
B es de 2 x 3
Entonces A + B se puede calcular.

Si las dimensiones no coinciden, la operación no está definida.

61.3 Suma de matrices

La suma se realiza elemento por elemento.

[1 2] + [5 6] = [6 8]
[3 4] [7 8] [10 12]

Cada posición de la matriz resultado suma los valores de la misma posición en las matrices originales.

61.4 Suma en JavaScript

Para sumar matrices en código, se recorren filas y columnas y se construye una nueva matriz.

function sumarMatrices(a, b) {
  const resultado = [];

  for (let fila = 0; fila < a.length; fila++) {
    resultado[fila] = [];

    for (let columna = 0; columna < a[fila].length; columna++) {
      resultado[fila][columna] = a[fila][columna] + b[fila][columna];
    }
  }

  return resultado;
}

const a = [[1, 2], [3, 4]];
const b = [[5, 6], [7, 8]];

console.log(sumarMatrices(a, b));

El resultado tiene la misma dimensión que las matrices de entrada.

61.5 Resta de matrices

La resta también se realiza elemento por elemento.

[9 8] - [1 2] = [8 6]
[7 6] [3 4] [4 2]

La posición de cada elemento se conserva en la matriz resultado.

61.6 Resta en JavaScript

La estructura del algoritmo es similar a la suma, pero cambia la operación interna.

function restarMatrices(a, b) {
  const resultado = [];

  for (let fila = 0; fila < a.length; fila++) {
    resultado[fila] = [];

    for (let columna = 0; columna < a[fila].length; columna++) {
      resultado[fila][columna] = a[fila][columna] - b[fila][columna];
    }
  }

  return resultado;
}

const a = [[9, 8], [7, 6]];
const b = [[1, 2], [3, 4]];

console.log(restarMatrices(a, b));

Este patrón sirve para comparar tablas de datos o estados de un sistema.

61.7 Multiplicación por escalar

Un escalar es un número común. Multiplicar una matriz por un escalar significa multiplicar cada elemento por ese número.

3 · [1 2] = [3 6]
[4 5] [12 15]

La dimensión de la matriz no cambia.

61.8 Multiplicación por escalar en JavaScript

Se recorre la matriz y se multiplica cada elemento por el escalar.

function multiplicarPorEscalar(matriz, escalar) {
  const resultado = [];

  for (let fila = 0; fila < matriz.length; fila++) {
    resultado[fila] = [];

    for (let columna = 0; columna < matriz[fila].length; columna++) {
      resultado[fila][columna] = matriz[fila][columna] * escalar;
    }
  }

  return resultado;
}

const matriz = [[1, 2], [4, 5]];

console.log(multiplicarPorEscalar(matriz, 3));

Esta operación se usa para escalar valores de una tabla completa.

61.9 Matriz transpuesta

La transpuesta de una matriz intercambia filas por columnas.

A = [1 2 3]
    [4 5 6]

Aᵀ = [1 4]
     [2 5]
     [3 6]

Si la matriz original es de 2 x 3, su transpuesta es de 3 x 2.

61.10 Transpuesta en JavaScript

Para transponer, se toma cada columna original y se convierte en una fila nueva.

function transponer(matriz) {
  const resultado = [];
  const filas = matriz.length;
  const columnas = matriz[0].length;

  for (let columna = 0; columna < columnas; columna++) {
    resultado[columna] = [];

    for (let fila = 0; fila < filas; fila++) {
      resultado[columna][fila] = matriz[fila][columna];
    }
  }

  return resultado;
}

const matriz = [[1, 2, 3], [4, 5, 6]];

console.log(transponer(matriz));

La transposición es útil al reorganizar datos para cálculos o visualizaciones.

61.11 Producto de matrices

El producto de matrices combina filas de la primera matriz con columnas de la segunda.

Para calcular A · B:
columnas de A debe coincidir con filas de B.

Si A es de 2 x 3 y B es de 3 x 4, el resultado será de 2 x 4.

61.12 Producto de matrices en JavaScript

El cálculo requiere tres ciclos: uno para filas, otro para columnas y otro para acumular productos.

function multiplicarMatrices(a, b) {
  const filasA = a.length;
  const columnasA = a[0].length;
  const columnasB = b[0].length;
  const resultado = [];

  for (let fila = 0; fila < filasA; fila++) {
    resultado[fila] = [];

    for (let columna = 0; columna < columnasB; columna++) {
      let suma = 0;

      for (let k = 0; k < columnasA; k++) {
        suma += a[fila][k] * b[k][columna];
      }

      resultado[fila][columna] = suma;
    }
  }

  return resultado;
}

const a = [[1, 2, 3], [4, 5, 6]];
const b = [[7, 8], [9, 10], [11, 12]];

console.log(multiplicarMatrices(a, b));

La variable k recorre los elementos que se multiplican y suman.

61.13 Validar dimensiones

Antes de operar matrices, conviene revisar que sus dimensiones sean compatibles.

function puedeMultiplicarse(a, b) {
  const columnasA = a[0].length;
  const filasB = b.length;
  return columnasA === filasB;
}

const a = [[1, 2, 3], [4, 5, 6]];
const b = [[7, 8], [9, 10], [11, 12]];
const c = [[1, 2], [3, 4]];

console.log(puedeMultiplicarse(a, b));
console.log(puedeMultiplicarse(a, c));

Validar dimensiones evita errores lógicos antes de ejecutar un cálculo más costoso.

61.14 Aplicaciones en programación

Las operaciones con matrices se usan para transformar coordenadas, procesar imágenes, manejar datos tabulares, resolver sistemas y calcular modelos.

Ejemplos:
sumar matrices para combinar capas de datos;
multiplicar por escalar para ajustar intensidades;
transponer para reorganizar filas y columnas;
multiplicar matrices para aplicar transformaciones.

En software, estas operaciones suelen estar dentro de bibliotecas matemáticas optimizadas.

61.15 Conclusión

Las operaciones básicas con matrices amplían la utilidad de las tablas numéricas. Permiten combinar información, escalar valores y transformar estructuras.

Antes de operar matrices, siempre revisa sus dimensiones.

En el próximo tema se estudiarán aplicaciones de matrices en programación.

Volver al índice