Dos matrices son iguales cuando tienen el mismo orden y todos sus elementos correspondientes son iguales. En programación también debemos distinguir entre comparar referencias, contenidos exactos y resultados aproximados.
Comparar matrices es necesario para comprobar resultados, validar datos, resolver ecuaciones y escribir pruebas automatizadas. La igualdad matricial posee una definición precisa: no basta con que las matrices tengan algunos valores en común o la misma cantidad total de elementos.
Debemos comprobar dos condiciones:
Sean A y B dos matrices. Si A tiene orden m × n y B tiene orden p × q, entonces A = B solamente si:
La igualdad se escribe A = B. Cuando no se cumplen las condiciones, escribimos A ≠ B.
Dos matrices de dimensiones diferentes nunca son iguales, aunque contengan los mismos números o la misma cantidad total de elementos.
function tienenMismoOrden(A, B) {
if (!A.length || !B.length) return false;
return A.length === B.length &&
A[0].length === B[0].length;
}
console.log(tienenMismoOrden([[1, 2, 3, 4]], [[1, 2], [3, 4]]));Una vez comprobado el orden, comparamos cada elemento con el que ocupa la misma fila y columna en la otra matriz.
La comparación siempre relaciona posiciones iguales. No podemos cambiar el orden de filas o columnas para intentar obtener igualdad.
| Matriz A | Matriz B | Motivo |
|---|---|---|
| [[3, 5]] | [[3, 5]] | Mismo orden y mismos elementos |
| [[2], [7]] | [[1 + 1], [10 - 3]] | Las expresiones producen los mismos valores |
| [[0, 0], [0, 0]] | O2×2 | Ambas son la matriz nula 2 × 2 |
| [[1, 0], [0, 1]] | I2 | Ambas representan la identidad de orden 2 |
Los nombres y las expresiones utilizadas para obtener los elementos pueden ser diferentes. Lo que importa es el valor final de cada posición.
Las siguientes situaciones producen matrices distintas:
Cuando una matriz contiene incógnitas, la igualdad con otra matriz permite formar una ecuación por cada par de elementos correspondientes.
const x = 5 - 1;
const y = 6 + 2;
const A = [[x + 1, 2], [3, y - 2]];
const B = [[5, 2], [3, 6]];
console.log("x =", x);
console.log("y =", y);
console.log(A, B);La igualdad de matrices es una relación de equivalencia y cumple tres propiedades.
Estas propiedades permiten sustituir una matriz por otra igual dentro de cualquier expresión compatible.
El operador === aplicado a arreglos no compara sus elementos. Comprueba si ambas variables apuntan al mismo objeto en memoria.
const A = [[1, 2], [3, 4]];
const B = [[1, 2], [3, 4]];
const C = A;
console.log(A === B);
console.log(A === C);A y B tienen contenidos matemáticamente iguales, pero son objetos distintos. C contiene la misma referencia que A, por eso A === C es verdadero.
Para comparar contenidos debemos recorrer las matrices y revisar dimensiones y valores.
function matricesIguales(A, B) {
if (A.length !== B.length) return false;
return A.every((fila, i) =>
fila.length === B[i].length &&
fila.every((valor, j) => valor === B[i][j])
);
}
const A = [[1, 2], [3, 4]];
const B = [[1, 2], [3, 4]];
const C = [[1, 2], [4, 3]];
console.log(matricesIguales(A, B));
console.log(matricesIguales(A, C));Una comparación robusta debe rechazar valores que no sean matrices rectangulares válidas.
function esMatrizValida(matriz) {
if (!Array.isArray(matriz) || matriz.length === 0) return false;
if (!matriz.every(fila => Array.isArray(fila))) return false;
const columnas = matriz[0].length;
return columnas > 0 && matriz.every(fila =>
fila.length === columnas && fila.every(Number.isFinite)
);
}
console.log(esMatrizValida([[1, 2], [3, 4]]));
console.log(esMatrizValida([[1, 2], [3]]));
console.log(esMatrizValida([[1, 2], [3, NaN]]));Esta función exige filas de igual longitud y elementos numéricos finitos.
Las computadoras representan muchos números decimales mediante aproximaciones binarias. Por eso, dos cálculos matemáticamente equivalentes pueden no producir exactamente el mismo valor almacenado.
const A = [[0.1 + 0.2]];
const B = [[0.3]];
console.log(A[0][0]);
console.log(B[0][0]);
console.log(A[0][0] === B[0][0]);En matemática esperamos igualdad, pero la comparación exacta de JavaScript devuelve falso debido al redondeo de punto flotante.
Para resultados numéricos podemos considerar iguales dos valores si su diferencia absoluta es menor o igual que una tolerancia.
function matricesCasiIguales(A, B, tolerancia = 1e-9) {
if (A.length !== B.length) return false;
return A.every((fila, i) =>
fila.length === B[i].length &&
fila.every((valor, j) =>
Math.abs(valor - B[i][j]) <= tolerancia
)
);
}
console.log(matricesCasiIguales([[0.1 + 0.2]], [[0.3]]));La tolerancia adecuada depende de la precisión necesaria y de la escala de los datos.
Una tolerancia absoluta puede ser inadecuada cuando los valores son muy grandes o muy pequeños. Podemos ajustar el límite según la magnitud de los números comparados.
function casiIguales(a, b, tolerancia = 1e-9) {
const escala = Math.max(1, Math.abs(a), Math.abs(b));
return Math.abs(a - b) <= tolerancia * escala;
}
function matricesCasiIguales(A, B, tolerancia = 1e-9) {
return A.length === B.length && A.every((fila, i) =>
fila.length === B[i].length &&
fila.every((valor, j) => casiIguales(valor, B[i][j], tolerancia))
);
}
console.log(matricesCasiIguales(
[[1000000000, 0.000001]],
[[1000000000.1, 0.0000010000001]]
));Esta estrategia combina un piso absoluto con una comparación proporcional a la escala.
Además de obtener verdadero o falso, puede ser útil conocer el mayor error entre elementos correspondientes.
function diferenciaMaxima(A, B) {
if (A.length !== B.length ||
A.some((fila, i) => fila.length !== B[i].length)) {
return Infinity;
}
let maxima = 0;
A.forEach((fila, i) =>
fila.forEach((valor, j) => {
maxima = Math.max(maxima, Math.abs(valor - B[i][j]));
})
);
return maxima;
}
const A = [[1, 2], [3, 4]];
const B = [[1.001, 2], [2.998, 4.0005]];
console.log(diferenciaMaxima(A, B));Este valor permite informar cuánto se alejan los resultados en lugar de limitarse a una decisión binaria.
Una copia puede comenzar siendo igual a la matriz original y dejar de serlo después de una modificación. Conviene copiar también cada fila para evitar compartir arreglos internos.
const A = [[1, 2], [3, 4]];
const copia = A.map(fila => [...fila]);
console.log("Antes:", JSON.stringify(A) === JSON.stringify(copia));
copia[0][0] = 99;
console.log("Después:", JSON.stringify(A) === JSON.stringify(copia));
console.log("Original:", A);
console.log("Copia:", copia);JSON.stringify resulta útil en este ejemplo simple, pero una función elemento a elemento permite controlar mejor validaciones y tolerancias.
La comparación de matrices permite verificar que una operación produzca el resultado esperado.
function transponer(matriz) {
return matriz[0].map((_, j) =>
matriz.map(fila => fila[j])
);
}
function matricesIguales(A, B) {
return A.length === B.length && A.every((fila, i) =>
fila.length === B[i].length &&
fila.every((valor, j) => valor === B[i][j])
);
}
const resultado = transponer([[1, 2, 3], [4, 5, 6]]);
const esperado = [[1, 4], [2, 5], [3, 6]];
console.log("Prueba aprobada:", matricesIguales(resultado, esperado));En aplicaciones científicas suele utilizarse una comparación aproximada para verificar algoritmos que realizan numerosos cálculos decimales.
La igualdad matricial exige coincidencia de forma y contenido. En programación debemos traducir esta definición a un recorrido completo y elegir entre comparación exacta o aproximada según el origen de los valores.
En el próximo tema aprenderemos a sumar y restar matrices del mismo orden, aplicando operaciones elemento a elemento.