Método de falsa posición

01 · Punto de partida

Una alternativa al punto medio

Bisección divide el intervalo exactamente por la mitad sin considerar cuánto valen f(a) y f(b). El método de falsa posición —también llamado regula falsi— utiliza esos valores para dibujar la recta que une los puntos (a,f(a)) y (b,f(b)).

La intersección de esa secante con el eje horizontal se toma como nueva aproximación. Luego conservamos el subintervalo que mantiene el cambio de signo.

02 · Condiciones iniciales

Requisitos del método

Comenzamos con las mismas condiciones fundamentales que en bisección:

También debemos garantizar:

• evaluaciones finitas en los puntos utilizados;
• un denominador f(b)−f(a) distinto de cero;
• tolerancias y máximo de iteraciones válidos;
• continuidad dentro del intervalo, no solo signos opuestos.

Si uno de los extremos ya satisface f(x)=0, se devuelve inmediatamente. Si no hay cambio de signo, falsa posición pierde su garantía de encierro.

03 · Interpolación lineal

Derivar la fórmula

La recta que pasa por (a,f(a)) y (b,f(b)) tiene pendiente:

Partiendo del extremo a, buscamos el valor c donde la recta aproximada vale cero:

Despejando:

Una forma algebraicamente equivalente es:

En código preferiremos la primera forma, calculando primero los cocientes, porque evita algunos productos grandes. Ninguna fórmula elimina todos los riesgos de escala extrema.

function puntoFalsaPosicion(a, b, fa, fb) {
  const denominador = fb - fa;
  if (denominador === 0) {
    throw new Error("La secante es horizontal");
  }
  return a - fa * ((b - a) / denominador);
}

console.log(puntoFalsaPosicion(1, 2, -2, 4)); // 1.333333...

04 · Procedimiento

El algoritmo paso a paso

1. 1
   Interpolar.

   Calcular c mediante la secante de los extremos.

2. 2
   Evaluar.

   Obtener f(c) y comprobar que sea finito.

3. 3
   Finalizar si corresponde.

   Comprobar raíz exacta, residuo, cambio, intervalo y límites.

4. 4
   Actualizar el extremo derecho.

   Si f(a) y f(c) tienen signos opuestos, asignar b=c.

5. 5
   Actualizar el extremo izquierdo.

   En caso contrario, asignar a=c.

6. 6
   Repetir.

   La raíz permanece encerrada si se mantienen las precondiciones.

05 · Seguridad del intervalo

El invariante de encierro

Al igual que bisección, falsa posición conserva extremos de signos opuestos:

La aproximación c queda dentro de [a,b] cuando f(a) y f(b) tienen signos opuestos y las operaciones se realizan correctamente.

La diferencia principal es que el intervalo no se divide necesariamente por la mitad. La posición de c depende de las alturas relativas de la función. Puede quedar cerca de un extremo.

function signosOpuestos(x, y) {
  return (x < 0 && y > 0) || (x > 0 && y < 0);
}

function actualizarIntervalo(a, b, fa, fb, c, fc) {
  if (signosOpuestos(fa, fc)) {
    return { a, b: c, fa, fb: fc };
  }
  return { a: c, b, fa: fc, fb };
}

06 · Ejemplo manual

Resolver x³−x−2=0

Comenzamos en [1,2], con f(1)=−2 y f(2)=4.

El extremo derecho permanece fijo porque cada nueva aproximación tiene el mismo signo que el extremo izquierdo. Aun así, las aproximaciones se acercan a la raíz 1.521379….

07 · Comparación directa

Falsa posición frente a bisección

Cuando la función se parece a una recta en el intervalo, la interpolación puede acercarse rápidamente. Cuando las alturas de los extremos están muy desequilibradas, el nuevo punto puede quedar repetidamente cerca del mismo lado.

08 · Principal dificultad

Bloqueo de un extremo

En funciones muy curvas, uno de los extremos puede permanecer sin cambios durante muchas iteraciones. La secante sigue utilizando su valor grande y produce aproximaciones pegadas al extremo opuesto.

Por ejemplo, para f(x)=x¹⁰−1 en [0,1.5]:

La primera intersección queda cerca de 0.026, muy lejos de la raíz x=1. El extremo derecho puede permanecer fijo y la convergencia se vuelve lenta.

const f = x => x ** 10 - 1;
let a = 0;
let b = 1.5;

for (let i = 1; i <= 6; i++) {
  const fa = f(a);
  const fb = f(b);
  const c = a - fa * ((b - a) / (fb - fa));
  console.log(i, c, f(c));
  a = c; // en estas primeras iteraciones, f(c) sigue siendo negativa
}

09 · Análisis

Convergencia y criterios de parada

La falsa posición clásica suele converger linealmente, pero el factor puede ser desfavorable cuando un extremo queda bloqueado. No disponemos de la reducción geométrica fija del ancho que ofrece bisección.

Conviene observar varias medidas:

Residuo

|f(cₙ)|, cumplimiento de la ecuación.

Cambio

|cₙ−cₙ₋₁|, estabilización de las aproximaciones.

Ancho

|bₙ−aₙ|, tamaño del intervalo, aunque puede reducirse lentamente.

Extremo fijo

Cantidad de iteraciones durante las que un lado no se actualiza.

Un cambio pequeño puede deberse a bloqueo y no a una aproximación precisa. Por eso es especialmente importante combinarlo con residuo y máximo de iteraciones.

10 · Código reutilizable

Implementación robusta en JavaScript

function falsaPosicion(funcion, inicio, fin, opciones = {}) {
  const {
    toleranciaX = 1e-10,
    toleranciaF = 1e-10,
    maxIteraciones = 100,
    guardarHistorial = false
  } = opciones;

  if (!(inicio < fin)) throw new Error("El intervalo debe estar ordenado");
  if (!(toleranciaX > 0) || !(toleranciaF > 0)) {
    throw new Error("Las tolerancias deben ser positivas");
  }
  if (!Number.isInteger(maxIteraciones) || maxIteraciones < 1) {
    throw new Error("El máximo de iteraciones debe ser un entero positivo");
  }

  let a = inicio;
  let b = fin;
  let fa = funcion(a);
  let fb = funcion(b);
  let anterior = null;
  const historial = [];

  if (!Number.isFinite(fa) || !Number.isFinite(fb)) {
    throw new Error("La función no es finita en los extremos");
  }
  if (fa === 0) return resultado(a, true, "extremo_izquierdo", 0);
  if (fb === 0) return resultado(b, true, "extremo_derecho", 0);
  if (!signosOpuestos(fa, fb)) {
    throw new Error("Los extremos no encierran un cambio de signo");
  }

  for (let iteracion = 1; iteracion <= maxIteraciones; iteracion++) {
    const denominador = fb - fa;
    if (denominador === 0 || !Number.isFinite(denominador)) {
      return resultado(anterior, false, "secante_invalida", iteracion - 1,
        { a, b, historial });
    }

    const c = a - fa * ((b - a) / denominador);
    const fc = funcion(c);
    const cambio = anterior === null ? Infinity : Math.abs(c - anterior);
    const limiteCambio = toleranciaX * Math.max(1, Math.abs(c));

    if (!Number.isFinite(c) || !Number.isFinite(fc)) {
      return resultado(c, false, "valor_no_finito", iteracion,
        { a, b, residuo: Math.abs(fc), historial });
    }
    if (guardarHistorial) {
      historial.push({ iteracion, a, b, c, fa, fb, fc, cambio });
    }
    if (fc === 0) {
      return resultado(c, true, "raiz_exacta", iteracion,
        { a, b, residuo: 0, cambio, historial });
    }
    if (Math.abs(fc) <= toleranciaF
        && cambio <= limiteCambio) {
      return resultado(c, true, "tolerancias", iteracion,
        { a, b, residuo: Math.abs(fc), cambio, historial });
    }
    if (c === a || c === b || c === anterior) {
      return resultado(c, false, "estancamiento", iteracion,
        { a, b, residuo: Math.abs(fc), cambio, historial });
    }

    if (signosOpuestos(fa, fc)) {
      b = c;
      fb = fc;
    } else {
      a = c;
      fa = fc;
    }
    anterior = c;
  }

  return resultado(anterior, false, "maximo_iteraciones",
    maxIteraciones, {
      a, b,
      residuo: Math.abs(funcion(anterior)),
      historial
    });
}

function signosOpuestos(x, y) {
  return (x < 0 && y > 0) || (x > 0 && y < 0);
}

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

La implementación exige simultáneamente residuo y cambio. También detecta secantes inválidas, valores no finitos y estancamiento.

11 · Evitar el bloqueo

Variante de Illinois

El método de Illinois modifica el peso del extremo que permanece fijo. Si el mismo lado sobrevive en iteraciones consecutivas, divide por dos el valor de función utilizado para construir la siguiente secante.

El punto del intervalo no cambia; solo se reduce temporalmente su influencia en la interpolación. Esto empuja la próxima secante hacia el extremo bloqueado.

function pasoIllinois(estado, funcion) {
  let { a, b, fa, fb, ladoAnterior } = estado;
  const c = a - fa * ((b - a) / (fb - fa));
  const fc = funcion(c);

  if (fc === 0) {
    return { a: c, b: c, fa: 0, fb: 0, ladoAnterior: 0, c, fc };
  }
  if (signosOpuestos(fa, fc)) {
    b = c;
    fb = fc;
    if (ladoAnterior === -1) fa /= 2; // a volvió a quedar fijo
    ladoAnterior = -1;
  } else {
    a = c;
    fa = fc;
    if (ladoAnterior === 1) fb /= 2; // b volvió a quedar fijo
    ladoAnterior = 1;
  }
  return { a, b, fa, fb, ladoAnterior, c, fc };
}

Existen otras variantes, como Pegasus y Anderson–Björck. Todas intentan conservar el encierro evitando que una altura domine indefinidamente la secante.

12 · Elegir el método

¿Cuándo conviene falsa posición?

Una estrategia híbrida puede usar falsa posición mientras progresa y recurrir a bisección cuando detecta bloqueo o una reducción insuficiente del intervalo.

13 · Exploración interactiva

Laboratorio: falsa posición frente a bisección

Compará el error absoluto de ambas aproximaciones después de la misma cantidad de evaluaciones. La función x¹⁰−1 muestra el bloqueo clásico de falsa posición.

Preguntas para explorar

1. En la función cúbica, ¿qué método tiene menor error durante las primeras iteraciones?
2. Seleccioná x¹⁰−1. ¿Qué extremo parece quedar bloqueado?
3. ¿El error de bisección disminuye de manera monótona en el punto medio?
4. ¿Por qué conservar el intervalo no garantiza que su ancho disminuya rápidamente?

14 · Resultados auditables

Detectar progreso insuficiente

Además de devolver aproximación, residuo e iteraciones, una implementación puede registrar:

• cuántas veces consecutivas permaneció fijo cada extremo;
• la razón entre el ancho nuevo y el anterior;
• la reducción del residuo;
• si la secante quedó demasiado cerca de un extremo;
• si fue necesario activar Illinois o un paso de bisección.

function hayBloqueo(historial, limite = 5) {
  if (historial.length < limite + 1) return false;
  const ultimos = historial.slice(-(limite + 1));

  const mismoA = ultimos.every(fila => fila.a === ultimos[0].a);
  const mismoB = ultimos.every(fila => fila.b === ultimos[0].b);
  return mismoA || mismoB;
}

El diagnóstico permite cambiar de estrategia antes de desperdiciar muchas evaluaciones.

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: calcular la primera aproximación

Aplicá una iteración de falsa posición a f(x)=x²−2 en [1,2].

Ejercicio 2: comparar con bisección

Para el mismo problema anterior, ¿cuál es la primera aproximación de bisección y cuál tiene menor error respecto de √2?

Ejercicio 3: reconocer bloqueo

En una tabla de diez iteraciones, el extremo b conserva exactamente el mismo valor mientras a avanza muy poco. ¿Qué problema aparece y qué alternativas propondrías?

Ejercicio 4: precondiciones

¿Puede aplicarse falsa posición a f(x)=1/(x−1) en [0,2]?

Ejercicio 5: criterio de parada

Modificá la implementación para aceptar el resultado si el residuo es pequeño y el intervalo ya tiene un ancho menor que una tolerancia adicional.

const anchoAceptable = Math.abs(b - a) <= toleranciaIntervalo;
const residuoAceptable = Math.abs(fc) <= toleranciaF;

if (anchoAceptable && residuoAceptable) {
  return resultado(c, true, "intervalo_y_residuo",
    iteracion, {
      a, b,
      ancho: Math.abs(b - a),
      residuo: Math.abs(fc),
      historial
    });
}

17 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos la iteración de punto fijo: cómo transformar una ecuación en x=g(x) y determinar si las iteraciones convergerán.