Criterios de parada y tolerancia

01 · Punto de partida

Un proceso infinito debe convertirse en un programa finito

Muchos métodos matemáticos describen una sucesión que continúa indefinidamente y se acerca a una respuesta. Un programa, en cambio, necesita devolver un resultado después de una cantidad finita de operaciones.

Para aproximar √2 mediante el método de Newton podemos iterar:

Desde x₀=1 aparecen 1.5, 1.416666…, 1.414215… y valores cada vez más cercanos. Pero ¿cuándo debe detenerse el ciclo? “Cuando parezca suficiente” no es una instrucción ejecutable.

let x = 1;

while (/* ¿qué condición indica continuar? */) {
  x = (x + 2 / x) / 2;
}

Una regla de parada debe conectar la matemática con la necesidad concreta: precisión requerida, costo disponible y riesgos si el método no se comporta como esperamos.

02 · Tres preguntas diferentes

Aceptación, seguridad y diagnóstico

Una implementación robusta no usa una única condición indistinta. Separa por qué aceptaría el resultado, cuándo debe abandonar y qué información devolverá para explicar lo ocurrido.

Alcanzar el máximo de iteraciones no equivale a converger. Ambos eventos terminan el ciclo, pero solo el primero es una salida de seguridad. El programa debe comunicar esa diferencia al código que consume el resultado.

03 · Qué cantidad comparar

Cuatro criterios frecuentes

La tolerancia ε es un umbral. Su significado depende de la cantidad a la que se aplica:

Estas expresiones no son intercambiables. Un cambio pequeño puede acompañar un residuo grande; un residuo pequeño puede corresponder a un error grande si la función es casi horizontal; un intervalo pequeño es útil solamente si sabemos que conserva una solución.

04 · La escala del problema

Tolerancia absoluta y tolerancia relativa

Una tolerancia absoluta mide una distancia en las unidades del resultado:

ε_abs=0.01 puede ser razonable para una longitud medida en metros si aceptamos un centímetro. Pero la misma distancia tiene distinta importancia frente a un resultado de 0.001 o de 1 000 000.

La tolerancia relativa compara con la escala:

Cerca de cero, el lado derecho también se acerca a cero y puede exigir una precisión imposible o innecesaria. Por eso suele combinarse:

05 · Una señal útil pero incompleta

El cambio entre iteraciones no siempre es el error

Detener cuando |xₙ−xₙ₋₁| es pequeño funciona bien en muchos métodos convergentes, pero responde “¿cuánto cambió el algoritmo?”, no “¿cuán lejos está la solución?”.

La regla lenta xₙ₊₁=xₙ+10⁻¹² cambia muy poco en cada paso aunque se encuentre lejos de cualquier objetivo. También un cálculo de punto flotante puede producir xₙ₊₁===xₙ porque el incremento ya no es representable, no porque haya alcanzado una solución.

const grande = 1e16;
const siguiente = grande + 1;

console.log(siguiente === grande); // true
// Cambio almacenado cero, pero no se comprobó ninguna ecuación.

06 · Volver al problema original

Residuo, error y condicionamiento

Al resolver f(x)=0, el residuo r=f(x̃) indica cuánto incumple la aproximación x̃ la ecuación. Es computable sin conocer la raíz exacta.

Sin embargo, residuo y error no son iguales. Consideremos f(x)=10⁻⁸(x−3). En x=1003, el error respecto de la raíz es 1000, pero el residuo vale apenas 10⁻⁵. Una función muy plana transforma errores grandes en residuos pequeños.

Si conocemos una cota inferior m>0 para la magnitud de la pendiente cerca de la raíz, puede obtenerse una cota aproximada:

Esta relación muestra por qué la escala y el condicionamiento importan. Normalizar el residuo mediante una magnitud característica también evita que las unidades o coeficientes decidan accidentalmente cuándo parar.

07 · Diseñar una política explícita

Criterios combinados: AND, OR y prioridades

Combinar condiciones exige decidir su lógica. Con AND, todas deben cumplirse; con OR, basta una. El resultado puede cambiar de forma importante:

const pasoAceptable = cambio <= toleranciaPaso;
const residuoAceptable = residuo <= toleranciaResiduo;

// Más exigente: confirma ambas señales.
const aceptarConAnd = pasoAceptable && residuoAceptable;

// Más permisivo: requiere justificar cualquiera de las dos.
const aceptarConOr = pasoAceptable || residuoAceptable;

Una política habitual es aceptar solo cuando cambio y residuo cumplen sus umbrales, mientras cualquier salvaguarda —valor no finito, tiempo o máximo de iteraciones— detiene con estado de fallo o resultado incompleto.

El orden también importa. Antes de declarar convergencia hay que descartar NaN e infinitos. Además, el estado devuelto debe incluir qué condición concreta produjo la salida.

08 · Cuando seguir ya no ayuda

Precisión de máquina, estancamiento y divergencia

Una tolerancia menor que la resolución disponible no obliga a obtener más precisión: puede crear un ciclo interminable. Cerca de una magnitud dada, Number posee una separación finita entre valores representables.

• Estancamiento: el nuevo estado coincide con el anterior sin satisfacer el criterio principal.
• Ciclo: reaparecen estados anteriores, por ejemplo alternando entre dos valores.
• Divergencia: una medida como el residuo o la magnitud crece persistentemente.
• Valor inválido: surge NaN, Infinity o una salida fuera del dominio.

if (!Number.isFinite(candidato)) {
  return { estado: 'fallo', motivo: 'valor-no-finito' };
}

if (Object.is(candidato, actual) && residuo > tolerancia) {
  return { estado: 'fallo', motivo: 'estancamiento' };
}

if (candidato === anteriorAnterior) {
  return { estado: 'fallo', motivo: 'ciclo-de-dos' };
}

Detectar divergencia universalmente es difícil. Puede observarse crecimiento sostenido durante varias iteraciones, pero algunos métodos atraviesan transitorios grandes antes de converger. El diagnóstico debe expresarse como criterio operativo, no como certeza matemática injustificada.

09 · Precisión con un propósito

Elegir tolerancias y límites de recursos

La tolerancia no debería elegirse copiando un número como 1e-12 sin contexto. Depende de:

• las unidades y la escala de la salida;
• la incertidumbre de los datos de entrada;
• el efecto del error en decisiones posteriores;
• la estabilidad y precisión del método;
• el costo de cada iteración y el tiempo disponible.

Si una medición de entrada tiene incertidumbre de ±0.1, exigir que el cálculo interno cambie menos de 10⁻¹⁵ puede consumir recursos sin mejorar el significado físico del resultado.

Un límite de recursos no es un criterio de calidad. Es una protección que debe producir un estado diferente de “éxito”.

10 · Exploración

Laboratorio: ¿cuándo se detiene el método?

Compará reglas de parada al aproximar √S. El gráfico muestra, en escala logarítmica, el cambio entre pasos y el residuo. El punto rojo indica la iteración en que la política seleccionada finaliza.

La altura representa el orden de magnitud: cuanto más baja una serie, menor es la medida. Los valores iguales a cero se muestran en el piso del gráfico.

Preguntas para explorar

1. Con Newton, compará cambio, residuo, AND y OR. ¿Siempre finalizan en la misma iteración?
2. Reducí el máximo de iteraciones. ¿Cómo se diferencia “presupuesto agotado” de “tolerancia alcanzada”?
3. Compará Newton y bisección con 10⁻¹². ¿Qué método necesita más pasos?
4. Usá la iteración amortiguada y una tolerancia estricta. ¿Un cambio pequeño garantiza rápidamente un residuo pequeño?

11 · Contratos claros en el código

Devolver resultado, calidad y motivo

Una función numérica debería devolver más que el valor. El consumidor necesita saber si se alcanzó la precisión solicitada:

function raizNewton(S, opciones = {}) {
  const {
    inicial = Math.max(1, S),
    toleranciaAbsoluta = 1e-12,
    toleranciaRelativa = 1e-10,
    maxIteraciones = 100
  } = opciones;

  if (!(S >= 0) || !Number.isFinite(S)) {
    return { ok: false, motivo: 'entrada-invalida' };
  }
  if (S === 0) {
    return { ok: true, valor: 0, iteraciones: 0, residuo: 0 };
  }

  let actual = inicial;
  for (let iteracion = 1; iteracion <= maxIteraciones; iteracion += 1) {
    const siguiente = (actual + S / actual) / 2;
    if (!Number.isFinite(siguiente)) {
      return { ok: false, motivo: 'valor-no-finito', iteracion };
    }

    const cambio = Math.abs(siguiente - actual);
    const umbral = toleranciaAbsoluta
      + toleranciaRelativa * Math.max(Math.abs(actual), Math.abs(siguiente));
    const residuo = Math.abs(siguiente * siguiente - S);

    if (cambio <= umbral && residuo <= toleranciaAbsoluta) {
      return { ok: true, valor: siguiente, iteraciones: iteracion, residuo };
    }
    if (Object.is(siguiente, actual)) {
      return { ok: false, valor: actual, motivo: 'estancamiento', iteracion };
    }
    actual = siguiente;
  }

  return { ok: false, valor: actual, motivo: 'max-iteraciones' };
}

Este ejemplo todavía requiere adaptar la escala del residuo para objetivos muy grandes o pequeños, pero establece un contrato: ok distingue aceptación de fallo y motivo conserva información diagnóstica.

Validar también las opciones

Las tolerancias deben ser finitas y no negativas; el máximo de iteraciones debe ser un entero positivo. Si las opciones son inválidas, conviene rechazarlas antes de comenzar:

function opcionesValidas(tolerancia, maxIteraciones) {
  return Number.isFinite(tolerancia)
    && tolerancia >= 0
    && Number.isSafeInteger(maxIteraciones)
    && maxIteraciones > 0;
}

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Ejercicios de comprensión

Ejercicio 1: absoluta y relativa

Compará a=1 000 000 y b=1 000 001 con tolerancia absoluta 0.01 y relativa 2·10⁻⁶.

Ejercicio 2: cambio pequeño engañoso

La iteración xₙ₊₁=xₙ+10⁻¹² busca resolver x=100 desde cero. ¿Por qué |xₙ₊₁−xₙ|<10⁻⁹ es un mal criterio?

Ejercicio 3: bisección

Un intervalo inicial tiene ancho 8 y se divide por la mitad en cada paso. ¿Cuántas bisecciones garantizan un ancho no mayor que 0.01?

Ejercicio 4: interpretar una salida

Un método devuelve {ok:false, valor:1.4142, motivo:'max-iteraciones'}. ¿Puede usarse el valor?

Ejercicio 5: función de comparación

Implementá una comparación con tolerancias absoluta y relativa.

function suficientementeCerca(a, b, absTol = 1e-12, relTol = 1e-9) {
  if (!Number.isFinite(a) || !Number.isFinite(b)) return a === b;
  const diferencia = Math.abs(a - b);
  const escala = Math.max(Math.abs(a), Math.abs(b));
  return diferencia <= absTol + relTol * escala;
}

14 · Síntesis

Ideas para recordar

En el último tema integraremos estas ideas en un proyecto completo para aproximar, medir y visualizar: diseñaremos el experimento, controlaremos el error y comunicaremos los resultados.