10. Suma y resta de matrices

10.1 Introducción

La suma y la resta son las primeras operaciones que realizaremos entre matrices completas. Ambas se calculan elemento a elemento: cada posición de una matriz se combina con la misma posición de la otra.

Esta correspondencia exige que las matrices tengan igual orden. Si una es 2 × 3 y otra es 3 × 2, no existe una forma de emparejar todas las posiciones conservando filas y columnas.

El resultado siempre conserva el orden de las matrices originales.

10.2 Condición de compatibilidad

Dos matrices pueden sumarse o restarse si cumplen simultáneamente estas condiciones:

• Tienen la misma cantidad de filas.
• Tienen la misma cantidad de columnas.

Tener la misma cantidad total de elementos no es suficiente: el orden debe coincidir.

10.3 Definición de la suma

Sean A y B matrices del mismo orden m × n. La matriz suma C = A + B se define mediante:

Cada elemento c_ij se obtiene sumando los elementos que ocupan la fila i y la columna j en A y B.

10.4 Ejemplo de suma

const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];

const suma = A.map((fila, i) =>
  fila.map((valor, j) => valor + B[i][j])
);

console.log(suma);

10.5 Definición de la resta

Sean A y B matrices del mismo orden. La matriz diferencia C = A - B se define mediante:

El orden de los operandos importa: a cada elemento de A se le resta el elemento correspondiente de B.

10.6 Ejemplo de resta

const A = [[8, 6], [5, 9]];
const B = [[3, 1], [2, 4]];

const resta = A.map((fila, i) =>
  fila.map((valor, j) => valor - B[i][j])
);

console.log(resta);

10.7 Implementación reutilizable

Podemos crear una función que reciba dos matrices, valide su orden y aplique la operación solicitada.

function operarMatrices(A, B, operacion) {
  if (A.length !== B.length ||
      A.some((fila, i) => fila.length !== B[i].length)) {
    throw new Error("Las matrices deben tener el mismo orden");
  }

  return A.map((fila, i) =>
    fila.map((valor, j) => operacion(valor, B[i][j]))
  );
}

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

console.log(operarMatrices(A, B, (a, b) => a + b));
console.log(operarMatrices(A, B, (a, b) => a - b));

La función separa el recorrido matricial de la operación aplicada a cada par de valores.

10.8 Validación completa de las matrices

Antes de comparar órdenes conviene verificar que cada entrada sea una matriz rectangular válida.

function obtenerOrden(matriz) {
  if (!Array.isArray(matriz) || matriz.length === 0) return null;
  if (!matriz.every(fila => Array.isArray(fila))) return null;

  const columnas = matriz[0].length;
  if (!columnas || !matriz.every(fila => fila.length === columnas)) {
    return null;
  }

  return [matriz.length, columnas];
}

function mismoOrden(A, B) {
  const ordenA = obtenerOrden(A);
  const ordenB = obtenerOrden(B);

  return ordenA !== null && ordenB !== null &&
    ordenA[0] === ordenB[0] && ordenA[1] === ordenB[1];
}

console.log(mismoOrden([[1, 2], [3, 4]], [[5, 6], [7, 8]]));
console.log(mismoOrden([[1, 2]], [[3], [4]]));

10.9 Propiedad conmutativa de la suma

El orden de los sumandos no modifica el resultado.

function sumar(A, B) {
  return A.map((fila, i) =>
    fila.map((valor, j) => valor + B[i][j])
  );
}

const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];

console.log("A + B:", sumar(A, B));
console.log("B + A:", sumar(B, A));

Esto ocurre porque la suma de números es conmutativa en cada posición.

10.10 Propiedad asociativa de la suma

Cuando sumamos tres matrices del mismo orden, podemos cambiar la agrupación sin alterar el resultado.

const sumar = (A, B) => A.map((fila, i) =>
  fila.map((valor, j) => valor + B[i][j])
);

const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];
const C = [[2, 2], [2, 2]];

console.log(sumar(sumar(A, B), C));
console.log(sumar(A, sumar(B, C)));

10.11 Matriz nula como elemento neutro

Sumar una matriz nula del mismo orden no modifica la matriz original.

const A = [[4, -2, 7], [1, 5, 3]];
const O = A.map(fila => fila.map(() => 0));

const resultado = A.map((fila, i) =>
  fila.map((valor, j) => valor + O[i][j])
);

console.log(resultado);

10.12 Matriz opuesta e inverso aditivo

La matriz opuesta de A se representa como -A y se obtiene cambiando el signo de cada elemento.

const A = [[2, -5], [3, 7]];
const opuesta = A.map(fila => fila.map(valor => -valor));

const suma = A.map((fila, i) =>
  fila.map((valor, j) => valor + opuesta[i][j])
);

console.log("-A:", opuesta);
console.log("A + (-A):", suma);

10.13 La resta no es conmutativa

En general, cambiar el orden de una resta cambia el signo de cada resultado.

function restar(A, B) {
  return A.map((fila, i) =>
    fila.map((valor, j) => valor - B[i][j])
  );
}

const A = [[8, 5], [2, 9]];
const B = [[3, 1], [7, 4]];

console.log("A - B:", restar(A, B));
console.log("B - A:", restar(B, A));

10.14 La resta no es asociativa

Tampoco podemos cambiar libremente la agrupación de varias restas.

Para evitar ambigüedades, conviene respetar los paréntesis o reescribir la expresión utilizando matrices opuestas:

10.15 Resumen de propiedades

10.16 Combinaciones de matrices

En fórmulas y programas es habitual combinar sumas, restas y multiplicaciones por escalares. Estas expresiones se llaman combinaciones lineales.

function combinacion(A, B, escalarA, escalarB) {
  return A.map((fila, i) =>
    fila.map((valor, j) =>
      escalarA * valor + escalarB * B[i][j]
    )
  );
}

const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];

console.log(combinacion(A, B, 2, -3));

La expresión 2A - 3B solo está definida si A y B tienen el mismo orden.

10.17 Aplicaciones en programación

La suma y la resta de matrices aparecen en numerosos contextos.

• Combinar desplazamientos o cambios de estado.
• Calcular la diferencia entre dos conjuntos de datos.
• Sumar capas o contribuciones en una imagen.
• Acumular fuerzas, velocidades o transformaciones compatibles.
• Calcular errores entre valores observados y estimados.

const observado = [[10, 12, 9], [8, 11, 13]];
const estimado = [[9, 11, 10], [8, 10, 12]];

const error = observado.map((fila, i) =>
  fila.map((valor, j) => valor - estimado[i][j])
);

console.log("Matriz de errores:", error);

10.18 Resultados nuevos y errores frecuentes

Los ejemplos anteriores crean una matriz nueva y conservan las entradas. Esta estrategia facilita razonar sobre el programa y evita efectos secundarios.

const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];

const resultadoNuevo = A.map((fila, i) =>
  fila.map((valor, j) => valor + B[i][j])
);

console.log("A permanece igual:", A);
console.log("Resultado nuevo:", resultadoNuevo);

Modificar A en el lugar puede ahorrar memoria en matrices grandes, pero también altera el dato original. La elección debe ser explícita y estar documentada.

Otros errores frecuentes son:

• Sumar matrices con diferente orden.
• Comparar solamente la cantidad total de elementos.
• Sumar una fila de A con una columna de B.
• Usar el operador + entre arreglos de JavaScript y obtener texto concatenado.
• Creer que la resta es conmutativa o asociativa.
• Olvidar validar que todas las filas tengan igual longitud.

10.19 Qué debes recordar de este tema

• La suma y la resta requieren matrices del mismo orden.
• Cada resultado c_ij se obtiene operando a_ij con b_ij.
• El resultado conserva las dimensiones de las matrices originales.
• La suma es conmutativa y asociativa.
• La matriz nula es el elemento neutro de la suma.
• La matriz opuesta cumple A + (-A) = O.
• La resta no es conmutativa ni asociativa.
• Crear un resultado nuevo evita modificar accidentalmente las matrices de entrada.

10.20 Conclusión

La suma y la resta de matrices se realizan elemento a elemento entre matrices del mismo orden. La suma es conmutativa y asociativa, posee a la matriz nula como elemento neutro y cada matriz tiene una opuesta. La resta, en cambio, depende del orden y de la agrupación.

En el próximo tema aprenderemos a multiplicar una matriz por un escalar y analizaremos cómo esa operación modifica todos sus elementos.