Método de bisección

01 · Punto de partida

Reducir la incertidumbre a la mitad

Supongamos que una función continua toma un valor negativo en a y uno positivo en b. Sabemos que existe al menos una raíz entre ambos puntos. El método de bisección utiliza esa garantía de una forma sencilla:

1. calcula el punto medio del intervalo;
2. evalúa la función en ese punto;
3. conserva la mitad que mantiene el cambio de signo;
4. repite el procedimiento.

Cada iteración reduce a la mitad el intervalo que encierra la raíz. No necesita derivadas, una estimación inicial muy precisa ni una forma particular de la función.

02 · Condiciones de aplicación

¿Cuándo podemos utilizar bisección?

Necesitamos un intervalo inicial [a,b] que satisfaga:

Intervalo válido

Los extremos son finitos, están ordenados y pertenecen al dominio.

Continuidad

La función no presenta saltos, huecos ni asíntotas dentro del intervalo.

Cambio de signo

Los valores de los extremos tienen signos opuestos.

Evaluaciones finitas

El algoritmo debe poder calcular la función sin producir NaN o infinitos.

Si f(a)=0 o f(b)=0, ya encontramos una raíz en un extremo y podemos finalizar antes de iterar.

03 · Procedimiento

El algoritmo paso a paso

Sea m el punto medio:

Esta forma evita el posible desbordamiento de (a+b)/2 cuando los extremos son muy grandes y tienen el mismo signo.

1. 1
   Evaluar el punto medio.

   Calcular f(m).

2. 2
   Comprobar una raíz exacta.

   Si f(m)=0, finalizar.

3. 3
   Elegir la mitad izquierda.

   Si f(a) y f(m) tienen signos opuestos, reemplazar b por m.

4. 4
   Elegir la mitad derecha.

   En caso contrario, reemplazar a por m.

5. 5
   Comprobar la parada.

   Evaluar ancho, residuo, iteraciones y posibles fallos.

04 · Garantía central

El invariante de encierro

Un invariante es una propiedad que permanece verdadera durante el algoritmo. En bisección mantenemos:

y la raíz buscada permanece dentro de [aₙ,bₙ], suponiendo continuidad. Después de evaluar m, elegimos exactamente la mitad que conserva esta propiedad.

Este invariante aporta dos ventajas:

• la aproximación nunca abandona la región garantizada;
• el ancho del intervalo proporciona una cota de error aunque el residuo sea difícil de interpretar.

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

console.log(signosOpuestos(-2, 4)); // true
console.log(signosOpuestos(-2, -1)); // false

Comparar signos directamente es preferible a comprobar x*y < 0, porque el producto podría desbordarse o subdesbordarse.

05 · Ejemplo manual

Resolver x³−x−2=0

Elegimos [1,2] porque f(1)=−2 y f(2)=4.

La raíz está cerca de 1.52138. La tabla no necesita conocerla: en cada fila solo utiliza signos y el punto medio.

06 · Precisión garantizada

Cota del error

Si el ancho inicial es L₀=b₀−a₀, después de n subdivisiones:

Si utilizamos el punto medio del intervalo resultante como aproximación, su distancia a cualquier raíz encerrada no supera la mitad del ancho:

Esta cota es independiente de la forma de la curva. No necesita conocer la derivada ni el valor exacto de la raíz.

Convención de conteo

Algunos libros llaman x₁ al punto medio inicial y escriben una cota L₀/2ⁿ. Aquí n cuenta intervalos ya actualizados; por eso el punto medio posterior tiene cota L₀/2ⁿ⁺¹. Ambas expresiones son compatibles si se declara la convención.

07 · Costo predecible

Calcular cuántas iteraciones necesitamos

Si queremos que el error del punto medio sea como máximo ε, imponemos:

Por lo tanto:

Si en cambio detenemos cuando el ancho completo es menor que tolAncho:

function divisionesParaError(longitudInicial, errorMaximo) {
  if (!(longitudInicial > 0) || !(errorMaximo > 0)) {
    throw new Error("Los valores deben ser positivos");
  }
  return Math.max(
    0,
    Math.ceil(Math.log2(longitudInicial / (2 * errorMaximo)))
  );
}

console.log(divisionesParaError(1, 1e-6)); // 19

Después de 19 subdivisiones de un intervalo de longitud 1, la cota del punto medio es menor o igual que 10⁻⁶.

08 · Criterios prácticos

¿Cuándo detener la bisección?

El ancho ofrece una garantía sobre x; el residuo controla f(x). Una implementación puede aceptar cualquiera de ellos o exigir ambos, según la aplicación.

09 · Código reutilizable

Implementación robusta en JavaScript

function biseccion(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");
  }

  let a = inicio;
  let b = fin;
  let fa = funcion(a);
  let fb = funcion(b);
  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 crearResultado(a, true, "extremo_izquierdo", 0);
  if (fb === 0) return crearResultado(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 medio = a + (b - a) / 2;
    const fm = funcion(medio);
    const cotaError = (b - a) / 2;

    if (!Number.isFinite(fm)) {
      return crearResultado(medio, false, "valor_no_finito",
        iteracion, { a, b, residuo: Math.abs(fm), historial });
    }
    if (guardarHistorial) {
      historial.push({ iteracion, a, b, medio, fm, cotaError });
    }
    if (fm === 0) {
      return crearResultado(medio, true, "raiz_exacta",
        iteracion, { a, b, residuo: 0, cotaError, historial });
    }
    if (cotaError <= toleranciaX || Math.abs(fm) <= toleranciaF) {
      return crearResultado(medio, true, "tolerancia",
        iteracion, { a, b, residuo: Math.abs(fm), cotaError, historial });
    }
    if (medio === a || medio === b) {
      return crearResultado(medio, false, "estancamiento",
        iteracion, { a, b, residuo: Math.abs(fm), cotaError, historial });
    }

    if (signosOpuestos(fa, fm)) {
      b = medio;
      fb = fm;
    } else {
      a = medio;
      fa = fm;
    }
  }

  const medio = a + (b - a) / 2;
  return crearResultado(medio, false, "maximo_iteraciones",
    maxIteraciones, {
      a, b, residuo: Math.abs(funcion(medio)),
      cotaError: (b - a) / 2, historial
    });
}

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

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

La función valida precondiciones, evita productos para comparar signos, calcula el medio con una forma segura y conserva diagnósticos.

10 · Ejecutar y verificar

Resolver la ecuación cúbica

const funcion = x => x ** 3 - x - 2;

const resultado = biseccion(funcion, 1, 2, {
  toleranciaX: 1e-12,
  toleranciaF: 1e-12,
  maxIteraciones: 100,
  guardarHistorial: true
});

console.log(resultado.valor);
console.log(resultado.residuo);
console.log(resultado.cotaError);
console.log(resultado.iteraciones);
console.table(resultado.historial.slice(0, 6));

La aproximación obtenida es cercana a 1.5213797068. La verificación debe incluir:

• un residuo pequeño;
• una cota de intervalo compatible con la tolerancia;
• convergio === true;
• un motivo esperado, no un máximo o estancamiento.

11 · Análisis del método

Convergencia lineal y costo

Bisección tiene convergencia lineal con factor 1/2 respecto del ancho:

Cada iteración gana aproximadamente un bit de precisión. Para ganar una cifra decimal se necesitan cerca de log₂(10) ≈ 3.32 iteraciones.

12 · Casos problemáticos

Cuándo bisección no es apropiada

13 · Exploración interactiva

Laboratorio: recorrer las subdivisiones

Elegí una función y mové el número de iteraciones. El gráfico resalta el intervalo que conserva el cambio de signo y marca su punto medio.

Preguntas para explorar

1. ¿Qué ocurre con la cota cada vez que agregás una subdivisión?
2. ¿El residuo disminuye en todas las iteraciones?
3. Compará las tres funciones con la misma cantidad de subdivisiones.
4. ¿Por qué el ancho permite una garantía aunque el residuo no disminuya de forma monótona?

14 · Contexto algorítmico

Bisección y búsqueda binaria

Ambos algoritmos dividen un intervalo a la mitad, pero resuelven problemas diferentes:

La estructura “dividir y descartar una mitad” es común, pero las precondiciones, invariantes y criterios de parada no son intercambiables.

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: verificar precondiciones

Determiná si bisección puede aplicarse a f(x)=x²−3 en [1,2], [−2,2] y [2,3].

Ejercicio 2: realizar iteraciones

Aplicá tres subdivisiones a f(x)=x²−2 comenzando en [1,2].

Ejercicio 3: cantidad de subdivisiones

Partiendo de un intervalo de longitud 8, ¿cuántas subdivisiones garantizan una cota del punto medio menor o igual que 10⁻⁵?

Ejercicio 4: detectar una falsa aplicación

Un programa aplica bisección a f(x)=1/(x−2) en [1,3]. Explicá el problema.

Ejercicio 5: modificar la política

Adaptá la implementación para exigir simultáneamente la cota de x y el residuo.

const cotaAceptable = cotaError <= toleranciaX;
const residuoAceptable = Math.abs(fm) <= toleranciaF;

if (cotaAceptable && residuoAceptable) {
  return crearResultado(medio, true, "ambas_tolerancias",
    iteracion, {
      a, b,
      residuo: Math.abs(fm),
      cotaError,
      historial
    });
}

17 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos el método de falsa posición, que conserva el intervalo con cambio de signo pero reemplaza el punto medio por una interpolación lineal.