18. Cálculo de determinantes de orden 2 y 3

Los determinantes de orden 2 y 3 pueden calcularse mediante fórmulas directas. Practicaremos el procedimiento con diagonales, cofactores, la regla de Sarrus y algoritmos en JavaScript.

18.1 Introducción

En los temas anteriores definimos el determinante y estudiamos sus propiedades. Ahora nos concentraremos en calcularlo correctamente para matrices de órdenes 2 y 3.

Estos casos son importantes porque aparecen en transformaciones 2D y 3D, áreas, volúmenes, sistemas pequeños y construcción de menores para matrices de mayor orden.

Orden 2: fórmula ad - bc.
Orden 3: cofactores o regla de Sarrus.

18.2 Determinante de orden 2

Sea A una matriz 2 × 2:

A = [a   b]
    [c   d]

Su determinante se calcula multiplicando los elementos de la diagonal principal y restando el producto de la diagonal secundaria.

det(A) = ad - bc

18.3 Procedimiento para orden 2

  1. Multiplica a por d.
  2. Multiplica b por c.
  3. Resta el segundo producto al primero.
A = [4   2]
    [1   3]

det(A) = 4·3 - 2·1
det(A) = 12 - 2
det(A) = 10

El orden de la resta es importante: diagonal principal menos diagonal secundaria.

18.4 Implementación básica para orden 2

function determinante2x2(A) {
  const a = A[0][0];
  const b = A[0][1];
  const c = A[1][0];
  const d = A[1][1];

  return a * d - b * c;
}

console.log(determinante2x2([[4, 2], [1, 3]]));

El resultado es 10.

18.5 Resultados positivos, negativos y nulos

Matriz Cálculo Resultado
[[4, 2], [1, 3]] 4·3 - 2·1 10
[[1, 3], [2, 4]] 1·4 - 3·2 -2
[[1, 2], [2, 4]] 1·4 - 2·2 0 
const det2 = A => A[0][0] * A[1][1] - A[0][1] * A[1][0];

console.log(det2([[4, 2], [1, 3]]));
console.log(det2([[1, 3], [2, 4]]));
console.log(det2([[1, 2], [2, 4]]));

18.6 Validación para una matriz 2 × 2

Una función reutilizable debe rechazar matrices de otro orden y valores no numéricos.

function determinante2x2(A) {
  const valida = Array.isArray(A) &&
    A.length === 2 &&
    A.every(fila =>
      Array.isArray(fila) && fila.length === 2 && fila.every(Number.isFinite)
    );

  if (!valida) throw new Error("Se requiere una matriz numérica 2 × 2");

  return A[0][0] * A[1][1] - A[0][1] * A[1][0];
}

console.log(determinante2x2([[3, 5], [2, 7]]));

18.7 Determinante de orden 3 por cofactores

Sea A una matriz 3 × 3:

A = [a   b   c]
    [d   e   f]
    [g   h   i]

Expandiendo por la primera fila obtenemos:

det(A) = a(ei - fh) - b(di - fg) + c(dh - eg)

Los signos alternan +, -, +.

18.8 Ejemplo por expansión de cofactores

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

det(A) = 2(4·6 - 5·2) - 1(0·6 - 5·1) + 3(0·2 - 4·1)
det(A) = 2(14) - 1(-5) + 3(-4)
det(A) = 28 + 5 - 12
det(A) = 21 
function det3PorCofactores(A) {
  const [[a, b, c], [d, e, f], [g, h, i]] = A;

  const menor11 = e * i - f * h;
  const menor12 = d * i - f * g;
  const menor13 = d * h - e * g;

  return a * menor11 - b * menor12 + c * menor13;
}

console.log(det3PorCofactores([[2, 1, 3], [0, 4, 5], [1, 2, 6]]));

18.9 Regla de Sarrus

La regla de Sarrus es un recurso visual exclusivo para matrices 3 × 3. Se copian las dos primeras columnas a la derecha y se forman seis productos diagonales.

Productos positivos:
aei + bfg + cdh

Productos negativos:
ceg + bdi + afh

det(A) = positivos - negativos

La regla no debe aplicarse a matrices 4 × 4 ni de otros órdenes.

18.10 Ejemplo con la regla de Sarrus

Para la misma matriz del ejemplo anterior:

Positivos = 2·4·6 + 1·5·1 + 3·0·2 = 48 + 5 + 0 = 53
Negativos = 3·4·1 + 1·0·6 + 2·5·2 = 12 + 0 + 20 = 32

det(A) = 53 - 32 = 21 
function det3Sarrus(A) {
  const [[a, b, c], [d, e, f], [g, h, i]] = A;

  const positivos = a * e * i + b * f * g + c * d * h;
  const negativos = c * e * g + b * d * i + a * f * h;

  return positivos - negativos;
}

console.log(det3Sarrus([[2, 1, 3], [0, 4, 5], [1, 2, 6]]));

18.11 Fórmula directa en JavaScript

Podemos escribir la fórmula de cofactores en una función compacta.

function determinante3x3(A) {
  const [[a, b, c], [d, e, f], [g, h, i]] = A;

  return a * (e * i - f * h)
       - b * (d * i - f * g)
       + c * (d * h - e * g);
}

console.log(determinante3x3([[1, 2, 3], [0, 1, 4], [5, 6, 0]]));

El resultado de este ejemplo es 1.

18.12 Cálculo explícito de menores y cofactores

Una implementación basada en menores hace visible el procedimiento matemático y puede adaptarse a otras filas.

function det2(A) {
  return A[0][0] * A[1][1] - A[0][1] * A[1][0];
}

function menor(A, filaEliminada, columnaEliminada) {
  return A
    .filter((_, i) => i !== filaEliminada)
    .map(fila => fila.filter((_, j) => j !== columnaEliminada));
}

function det3(A) {
  return A[0].reduce((suma, valor, j) => {
    const signo = j % 2 === 0 ? 1 : -1;
    return suma + signo * valor * det2(menor(A, 0, j));
  }, 0);
}

console.log(det3([[2, 1, 3], [0, 4, 5], [1, 2, 6]]));

18.13 Elegir una fila con ceros

La expansión por cofactores puede hacerse por cualquier fila o columna. Elegir una con ceros reduce la cantidad de menores necesarios.

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

det(A) = 2(4·6 - 5·2) = 2·14 = 28 
const A = [[2, 0, 0], [3, 4, 5], [1, 2, 6]];

const menor11 = A[1][1] * A[2][2] - A[1][2] * A[2][1];
const determinante = A[0][0] * menor11;

console.log(determinante);

18.14 Cálculo mediante triangularización

También podemos usar operaciones por filas para obtener una matriz triangular. El determinante será el producto de la diagonal, ajustado por los intercambios de filas.

function det3PorEliminacion(matriz, tolerancia = 1e-12) {
  const A = matriz.map(fila => [...fila]);
  let signo = 1;

  for (let i = 0; i < 3; i++) {
    let pivote = i;
    for (let fila = i + 1; fila < 3; fila++) {
      if (Math.abs(A[fila][i]) > Math.abs(A[pivote][i])) pivote = fila;
    }

    if (Math.abs(A[pivote][i]) <= tolerancia) return 0;
    if (pivote !== i) {
      [A[i], A[pivote]] = [A[pivote], A[i]];
      signo *= -1;
    }

    for (let fila = i + 1; fila < 3; fila++) {
      const factor = A[fila][i] / A[i][i];
      for (let columna = i; columna < 3; columna++) {
        A[fila][columna] -= factor * A[i][columna];
      }
    }
  }

  return signo * A[0][0] * A[1][1] * A[2][2];
}

console.log(det3PorEliminacion([[2, 1, 3], [0, 4, 5], [1, 2, 6]]));

18.15 Comparación de métodos

Método Órdenes Ventaja Limitación
ad - bc 2 × 2 Muy directo Solo orden 2
Sarrus 3 × 3 Visual y rápido Solo orden 3
Cofactores Cualquier orden General y conceptual Costoso para matrices grandes
Eliminación Cualquier orden Más eficiente Requiere controlar operaciones por filas

18.16 Verificar resultados con dos métodos

Durante el aprendizaje es útil implementar dos fórmulas independientes y comprobar que coincidan.

function porCofactores(A) {
  const [[a, b, c], [d, e, f], [g, h, i]] = A;
  return a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
}

function porSarrus(A) {
  const [[a, b, c], [d, e, f], [g, h, i]] = A;
  return (a * e * i + b * f * g + c * d * h)
       - (c * e * g + b * d * i + a * f * h);
}

const matrices = [
  [[2, 1, 3], [0, 4, 5], [1, 2, 6]],
  [[1, 2, 3], [0, 1, 4], [5, 6, 0]],
  [[1, 2, 3], [2, 4, 6], [7, 8, 9]]
];

matrices.forEach(A =>
  console.log(porCofactores(A), porSarrus(A))
);

Los pares de resultados deben coincidir: 21, 1 y 0.

18.17 Aplicaciones geométricas

En 2D, el determinante permite calcular el área orientada de un paralelogramo o el área de un triángulo.

function areaTriangulo(a, b, c) {
  const ab = [b[0] - a[0], b[1] - a[1]];
  const ac = [c[0] - a[0], c[1] - a[1]];
  const determinante = ab[0] * ac[1] - ab[1] * ac[0];

  return Math.abs(determinante) / 2;
}

console.log(areaTriangulo([0, 0], [4, 0], [1, 3]));

En 3D, el valor absoluto del determinante de tres vectores columna es el volumen del paralelepípedo que forman.

function volumenParalelepipedo(A) {
  const [[a, b, c], [d, e, f], [g, h, i]] = A;
  const det = a * (e * i - f * h)
            - b * (d * i - f * g)
            + c * (d * h - e * g);

  return Math.abs(det);
}

console.log(volumenParalelepipedo([[2, 0, 0], [0, 3, 0], [0, 0, 4]]));

18.18 Precisión y errores frecuentes

Con valores decimales conviene interpretar un determinante muy pequeño usando una tolerancia relacionada con la escala de la matriz.

function casiSingular3x3(A, factor = 100) {
  const [[a, b, c], [d, e, f], [g, h, i]] = A;
  const det = a * (e * i - f * h)
            - b * (d * i - f * g)
            + c * (d * h - e * g);
  const escala = Math.max(...A.flat().map(Math.abs));
  const tolerancia = factor * Number.EPSILON * Math.max(1, escala ** 3);

  return Math.abs(det) <= tolerancia;
}

console.log(casiSingular3x3([
  [0.1, 0.2, 0.3],
  [0.2, 0.4, 0.6],
  [1, 0, 1]
]));

Los errores más frecuentes son invertir la resta en orden 2, olvidar el signo negativo del segundo cofactor, sumar en lugar de restar las diagonales negativas de Sarrus, aplicar Sarrus a otro orden y comparar decimales siempre con cero exacto.

18.19 Qué debes recordar de este tema

  • Para orden 2, det(A) = ad - bc.
  • En orden 3, la expansión por la primera fila usa signos +, -, +.
  • La regla de Sarrus solo se aplica a matrices 3 × 3.
  • Expandir por una fila o columna con ceros reduce cálculos.
  • Cofactores y eliminación son métodos generalizables.
  • Un resultado cero indica una matriz singular.
  • El valor absoluto representa un área en 2D o un volumen en 3D.
  • Con decimales conviene utilizar una tolerancia ajustada a la escala.

18.20 Conclusión

Los determinantes de órdenes 2 y 3 pueden calcularse con fórmulas directas, pero comprender menores, cofactores y operaciones por filas prepara el camino para órdenes mayores y algoritmos numéricos.

En el próximo tema estudiaremos la matriz inversa, cuya existencia depende de que el determinante sea distinto de cero.

Volver al índice