Introducción

La reducción de filas (también conocida como eliminación de Gauss) es la técnica fundamental para resolver sistemas de ecuaciones lineales de la forma Ax = b. Cuando la matriz A contiene valores muy pequeños o ceros en la diagonal, el algoritmo básico puede volverse numéricamente inestable. El pivoteo parcial soluciona este problema al intercambiar filas de forma que el elemento pivote sea el de mayor valor absoluto en la columna actual.

En este artículo encontrarás:

• Fundamentos teóricos del algoritmo.
• Paso a paso de la reducción de filas con pivoteo parcial.
• Implementación práctica en Python usando numpy y scipy.
• Comparativas de rendimiento y precisión frente a LU decomposition y scipy.linalg.solve.
• Consejos de optimización, diagnóstico de errores comunes y mejores prácticas.

Fundamento Matemático

Sea A \in \mathbb{R}^{n\times n} una matriz no singular y b \in \mathbb{R}^{n}. El objetivo es transformar [A|b] en una forma escalonada superior U mediante operaciones elementales de fila, manteniendo la equivalencia del sistema:

U x = c

Donde c es el vector resultante después de aplicar las mismas operaciones a b. Posteriormente, se realiza sustitución regresiva para obtener x.

El pivoteo parcial garantiza que, en cada paso k, el pivote p = \max_{i\ge k} |a_{ik}| se sitúe en la posición a_{kk} mediante un intercambio de filas k ↔ i_{max}. Esto minimiza el factor de crecimiento y reduce la pérdida de precisión.

Algoritmo paso a paso

1. Inicialización: Copiar A y b a matrices de trabajo U y c.
2. Pivoteo parcial (columna k):
   • Encontrar i_{max} = \arg\max_{i\ge k} |U_{ik}|.
   • Si U_{i_{max}k}=0 → matriz singular, abortar.
   • Intercambiar filas k y i_{max} en U y c.
3. Eliminación:
   • Para cada fila i = k+1 … n-1 calcular el factor m = U_{ik}/U_{kk}.
   • Actualizar la fila: U_{i, k:} = U_{i, k:} - m * U_{k, k:} y c_i = c_i - m * c_k.
4. Repetir los pasos 2‑3 para k = 0 … n-2.
5. Sustitución regresiva: Resolver U x = c de abajo hacia arriba.

Implementación en Python

A continuación se muestra una implementación clara y didáctica usando numpy. El código está pensado para ser fácil de leer, no necesariamente el más rápido; sin embargo, incluye optimizations como np.float64 y uso de np.abs vectorizado.

import numpy as np
def gauss_partial_pivot(A, b):
    """Resuelve Ax = b mediante eliminación de Gauss con pivoteo parcial.
    Parámetros
    ----------
    A : ndarray (n, n)
        Matriz de coeficientes (no singular).
    b : ndarray (n,)
        Vector del lado derecho.
    Returns
    -------
    x : ndarray (n,)
        Solución del sistema.
    """
    A = A.astype(np.float64, copy=True)
    b = b.astype(np.float64, copy=True)
    n = A.shape[0]
    # --- Eliminación con pivoteo parcial ---
    for k in range(n-1):
        # 1. Selección del pivote
        i_max = np.argmax(np.abs(A[k:, k])) + k
        if np.isclose(A[i_max, k], 0.0):
            raise np.linalg.LinAlgError('Matriz singular o casi singular')
        # 2. Intercambio de filas
        if i_max != k:
            A[[k, i_max]] = A[[i_max, k]]
            b[[k, i_max]] = b[[i_max, k]]
        # 3. Eliminación
        for i in range(k+1, n):
            factor = A[i, k] / A[k, k]
            A[i, k:] -= factor * A[k, k:]
            b[i] -= factor * b[k]
    # --- Sustitución regresiva ---
    x = np.empty_like(b)
    for i in range(n-1, -1, -1):
        if np.isclose(A[i, i], 0.0):
            raise np.linalg.LinAlgError('División por cero en sustitución regresiva')
        x[i] = (b[i] - np.dot(A[i, i+1:], x[i+1:])) / A[i, i]
    return x

El bloque anterior está listo para ser copiado en cualquier proyecto. Para validar su funcionamiento, se incluyen dos casos de prueba.

# Caso 1: Sistema bien condicionado
A1 = np.array([[2., 1., -1.],
               [-3., -1., 2.],
               [-2., 1., 2.]])
b1 = np.array([8., -11., -3.])
print('Solución caso 1:', gauss_partial_pivot(A1, b1))
# Caso 2: Sistema con coeficientes muy desbalanceados
A2 = np.array([[1e-12, 1.],
               [1., 1.]])
b2 = np.array([1., 2.])
print('Solución caso 2:', gauss_partial_pivot(A2, b2))

En el segundo caso, sin pivoteo parcial, el algoritmo básico fallaría por pérdida de precisión. Con el pivoteo, la solución se mantiene estable.

Comparativa con LU Decomposition y scipy.linalg.solve

En entornos de producción donde la velocidad es crítica, la recomendación es usar scipy.linalg.solve o numpy.linalg.solve, que internamente realizan una factorización LU con pivoteo parcial y están altamente optimizados.

Rendimiento y Escalabilidad

El coste computacional de la eliminación de Gauss con pivoteo parcial es O(n³). A continuación se muestra una tabla de tiempos promedio (en milisegundos) en una máquina con CPU Intel i7‑12700K, Python 3.11 y numpy:

Para n > 10⁴ se recomienda usar librerías basadas en BLAS y MKL, o bien delegar la factorización a herramientas como SuiteSparse o Intel MKL.

Diagnóstico de errores comunes y mejores prácticas

• Matrix singular o casi singular: Verifique el rango con np.linalg.matrix_rank y considere regularizar el sistema (p.ej., Tikhonov).
• Pérdida de precisión: Use np.float128 (cuando el hardware lo permite) o reescalado de la matriz para reducir el número de condición.
• Overflow/underflow: Evite valores extremadamente grandes o pequeños; normalice la matriz antes de la eliminación.
• Iteraciones innecesarias: Cuando solo necesita la solución de varios vectores b_i con la misma A, factorice A una sola vez (LU) y reutilice la factorización.

Ejemplo de verificación del número de condición:

cond = np.linalg.cond(A)
print('Condición de A:', cond)
if cond > 1e12:
    print('Advertencia: posible pérdida de precisión')

Conclusiones

La reducción de filas con pivoteo parcial sigue siendo una herramienta esencial para comprender la solución de sistemas lineales y para casos donde se requiere un control total del proceso (educación, depuración o algoritmos personalizados). No obstante, para aplicaciones de alto rendimiento, la factorización LU de scipy.linalg o numpy.linalg es la opción preferida.

Dominar ambos enfoques permite a los ingenieros escoger la solución adecuada según el contexto: precisión didáctica vs. velocidad de producción.