Iteración de punto fijo

01 · Punto de partida

Una solución que no cambia al aplicar la función

Un número r es un punto fijo de una función g cuando:

Si transformamos una ecuación f(x)=0 en una forma equivalente x=g(x), sus soluciones se convierten en puntos fijos. Esto sugiere un algoritmo muy sencillo:

Comenzamos con una estimación x₀ y aplicamos repetidamente g. La sencillez de la fórmula oculta la decisión más importante: cómo elegir g.

Dos transformaciones algebraicamente equivalentes pueden producir:

• convergencia rápida hacia la solución;
• convergencia lenta;
• oscilación entre varios valores;
• alejamiento y crecimiento sin límite.

02 · De raíces a puntos fijos

Construir una función iteradora

Una misma ecuación puede reordenarse de muchas formas. Para x²−2=0:

Todas las expresiones mantienen √2 como punto fijo, pero su dinámica es diferente. La equivalencia algebraica no garantiza equivalencia numérica.

function iterar(g, inicial, cantidad) {
  const valores = [inicial];
  let x = inicial;

  for (let i = 0; i < cantidad; i++) {
    x = g(x);
    valores.push(x);
  }
  return valores;
}

console.log(iterar(x => 2 / x, 1, 6));
console.log(iterar(x => (x + 2 / x) / 2, 1, 6));

03 · Interpretación gráfica

Intersección de y=g(x) con y=x

Los puntos fijos son las intersecciones entre la curva y=g(x) y la diagonal y=x. El proceso iterativo puede visualizarse mediante un diagrama de telaraña:

1. 1
   Partir de x₀.

   Ubicar el valor inicial sobre el eje horizontal.

2. 2
   Subir hasta la curva.

   El punto vertical representa (x₀,g(x₀))=(x₀,x₁).

3. 3
   Ir a la diagonal.

   El movimiento horizontal lleva a (x₁,x₁).

4. 4
   Repetir.

   Desde allí volvemos a la curva para obtener x₂.

Si los segmentos forman una escalera o espiral que se cierra sobre la intersección, observamos convergencia. Si se alejan, el punto fijo es repulsivo para ese valor inicial.

04 · Criterio local

La derivada indica atracción o repulsión

Cerca de un punto fijo r, podemos aproximar:

Por lo tanto, el error local se multiplica aproximadamente por |g′(r)| en cada iteración.

El signo también describe el patrón: una derivada positiva suele acercarse desde un mismo lado; una negativa puede alternar alrededor de la solución.

05 · Garantía en un intervalo

Teorema de contracción

Un criterio local en la raíz es útil, pero la raíz todavía es desconocida. Podemos obtener una garantía sobre un intervalo [a,b] si:

1. g envía el intervalo dentro de sí mismo: g([a,b]) ⊆ [a,b];
2. existe un número q<1 tal que |g′(x)|≤q para todo x∈[a,b].

Entonces g tiene un único punto fijo en el intervalo y la iteración converge hacia él desde cualquier valor inicial del intervalo.

La desigualdad expresa que g contrae distancias. Cada aplicación acerca dos trayectorias al menos por el factor q.

06 · Ejemplo clásico

Resolver cos(x)=x

La ecuación ya está escrita como punto fijo:

En [0,1], cos(x) permanece dentro del intervalo y:

Por lo tanto, existe un único punto fijo en el intervalo y la iteración converge desde cualquier x₀∈[0,1].

let x = 1;

for (let iteracion = 1; iteracion <= 12; iteracion++) {
  const siguiente = Math.cos(x);
  console.log(iteracion, siguiente, Math.abs(siguiente - x));
  x = siguiente;
}

La solución es aproximadamente 0.7390851332. La convergencia es lineal y alternante porque g′(r)=−sin(r) es negativo.

07 · Cotas de error

Usar el factor de contracción

Si conocemos una cota q<1, podemos estimar el error sin conocer el punto fijo.

Cota a priori

Permite estimar antes de iterar cuántos pasos podrían ser necesarios.

Cota a posteriori

Utiliza el último cambio observado. Si q está cerca de 1, el factor q/(1−q) es grande y un cambio pequeño puede corresponder a un error todavía considerable.

function cotaPosteriori(q, anterior, actual) {
  if (!(q >= 0 && q < 1)) {
    throw new Error("q debe pertenecer a [0, 1)");
  }
  return q / (1 - q) * Math.abs(actual - anterior);
}

console.log(cotaPosteriori(0.85, 0.74, 0.739));

08 · Diseñar g(x)

Elegir una transformación conveniente

Al comparar funciones iteradoras buscamos:

• que tengan exactamente las raíces deseadas como puntos fijos;
• que estén definidas y sean finitas en la región de trabajo;
• que mantengan las iteraciones dentro de un intervalo válido;
• que |g′| sea menor que 1 y, preferentemente, pequeño;
• que su evaluación sea estable y poco costosa.

Ejemplo con √2

Para g(x)=½(x+2/x):

Esto explica la convergencia rápida cerca de la raíz. En cambio, para g(x)=2/x tenemos g′(√2)=−1, y desde x₀=1 se forma el ciclo 1→2→1→2….

09 · Modificar la dinámica

Relajación

Podemos combinar la iteración original con el valor actual:

El parámetro ω controla cuánto avanzamos:

La derivada en el punto fijo cambia a:

Elegir ω requiere estimar la dinámica. No existe un valor universalmente óptimo.

function relajar(g, omega) {
  return x => (1 - omega) * x + omega * g(x);
}

const oscilante = x => 2 / x;
const suavizada = relajar(oscilante, 0.5);

console.log(iterar(oscilante, 1, 5));
console.log(iterar(suavizada, 1, 5));

Con ω=0.5, la transformación resultante es precisamente el método babilónico.

10 · Dinámicas no convergentes

Divergencia, oscilación y escape

Una implementación debe detectar valores no finitos, estancamiento, ciclos cortos y máximo de iteraciones. La teoría local no protege una estimación inicial situada fuera de la región de atracción.

11 · Código reutilizable

Implementación robusta

function puntoFijo(g, inicial, opciones = {}) {
  const {
    residual = null,
    toleranciaAbsoluta = 1e-12,
    toleranciaRelativa = 1e-9,
    toleranciaResiduo = 1e-10,
    maxIteraciones = 100,
    guardarHistorial = false
  } = opciones;

  if (!Number.isFinite(inicial)) {
    throw new Error("El valor inicial debe ser finito");
  }
  if (!Number.isInteger(maxIteraciones) || maxIteraciones < 1) {
    throw new Error("El máximo debe ser un entero positivo");
  }

  let haceDos = null;
  let anterior = inicial;
  const historial = [];

  for (let iteracion = 1; iteracion <= maxIteraciones; iteracion++) {
    const actual = g(anterior);
    const cambio = Math.abs(actual - anterior);
    const limite = toleranciaAbsoluta
      + toleranciaRelativa * Math.abs(actual);
    const residuo = residual ? Math.abs(residual(actual)) : null;

    if (!Number.isFinite(actual)
        || (residuo !== null && !Number.isFinite(residuo))) {
      return crearResultado(actual, false, "valor_no_finito",
        iteracion, { cambio, residuo, historial });
    }
    if (guardarHistorial) {
      historial.push({ iteracion, anterior, actual, cambio, residuo });
    }

    const cambioAceptable = cambio <= limite;
    const residuoAceptable = residuo === null
      || residuo <= toleranciaResiduo;
    if (cambioAceptable && residuoAceptable) {
      return crearResultado(actual, true, "tolerancias",
        iteracion, { cambio, residuo, historial });
    }
    if (actual === anterior) {
      return crearResultado(actual, false, "estancamiento",
        iteracion, { cambio, residuo, historial });
    }
    if (haceDos !== null && actual === haceDos) {
      return crearResultado(actual, false, "ciclo_periodo_2",
        iteracion, { cambio, residuo, historial });
    }

    haceDos = anterior;
    anterior = actual;
  }

  const residuo = residual ? Math.abs(residual(anterior)) : null;
  return crearResultado(anterior, false, "maximo_iteraciones",
    maxIteraciones, { residuo, historial });
}

function crearResultado(valor, convergio, motivo, iteraciones, datos = {}) {
  return { valor, convergio, motivo, iteraciones, ...datos };
}

El residuo es opcional porque no toda aplicación conserva explícitamente la función original, aunque proporcionarlo mejora la verificación.

12 · Aplicar y verificar

Resolver cos(x)−x=0

const resultado = puntoFijo(
  x => Math.cos(x),
  1,
  {
    residual: x => Math.cos(x) - x,
    toleranciaAbsoluta: 1e-12,
    toleranciaRelativa: 1e-10,
    toleranciaResiduo: 1e-10,
    maxIteraciones: 100,
    guardarHistorial: true
  }
);

console.log(resultado);
console.table(resultado.historial.slice(0, 8));

La salida debe incluir aproximación, residuo, cambio, iteraciones y motivo. Si solo comprobáramos el cambio, una transformación con ciclo o estancamiento podría producir una interpretación incorrecta.

13 · Exploración interactiva

Laboratorio: diagramas de telaraña

Las cuatro transformaciones tienen √2 como punto fijo positivo, pero generan dinámicas diferentes. Elegí una, modificá x₀ y recorré las iteraciones.

Preguntas para explorar

1. Compará Herón y la transformación relajada con el mismo valor inicial.
2. Seleccioná 2/x. ¿Qué ciclo aparece desde x₀=1?
3. Probá la transformación repulsiva con valores iniciales cercanos a √2.
4. ¿Cómo se relaciona el diagrama con el valor de |g′(√2)|?

14 · Conexión con otros métodos

Newton-Raphson también es punto fijo

La iteración de Newton puede escribirse como:

En una raíz simple r, bajo condiciones adecuadas, g′(r)=0. Esto explica su convergencia cuadrática local.

La visión de punto fijo permite analizar muchos algoritmos con las mismas herramientas:

• puntos atractivos y repulsivos;
• regiones de convergencia;
• factores de contracción;
• relajación y aceleración;
• ciclos y estancamiento.

En el próximo tema derivaremos Newton geométricamente y estudiaremos sus ventajas y fallos específicos.

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: comprobar puntos fijos

Verificá que g(x)=½(x+3/x) tiene como puntos fijos reales a ±√3.

Ejercicio 2: clasificar una raíz

Para g(x)=cos(x) y el punto fijo r≈0.739085, estimá |g′(r)| y clasificá el punto.

Ejercicio 3: detectar un ciclo

Calculá cuatro iteraciones de g(x)=2/x desde x₀=1.

Ejercicio 4: cota a posteriori

Si q=0.6 y |xₙ−xₙ₋₁|=10⁻⁵, calculá la cota a posteriori.

Ejercicio 5: diseñar una iteración

Para f(x)=x³+x−1=0, proponé g(x)=1/(x²+1). Estudiá si es contractiva en [0,1].

17 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos el método de Newton-Raphson: su interpretación mediante rectas tangentes, su convergencia cuadrática y los cuidados necesarios para elegir el valor inicial.