El método de bisección es uno de los algoritmos más simples y robustos para encontrar raíces reales de funciones continuas. Su principio es dividir sucesivamente un intervalo en dos partes hasta localizar el punto donde la función cambia de signo, lo cual indica la presencia de una raíz.

En este artículo te mostraré cómo implementarlo en Java 21, cómo funciona paso a paso y por qué sigue siendo una herramienta esencial en análisis numérico.

⚙️ Fundamento teórico

Método de Bisección
Si una función continuamf(x) cumple que f(a) y f(b) tienen signos opuestos (es decir, f(a)⋅f(b)<0), 
entonces, por el Teorema del Valor Intermedio, existe al menos una raíz 𝑟 en el intervalo 
[a,b] tal que 
f(r)=0.
El método de bisección reduce el intervalo en cada iteración hasta que la longitud del intervalo es menor que una tolerancia deseada.
Pasos del algoritmo:
Escoger a y 𝑏 tales que f(a)⋅f(b)<0.

Calcular el punto medio c=(a+b)/2.

Evaluar f(c). Si f(c)=0, entonces c es la raíz.

Si f(a)⋅f(c)<0, la raíz está entre c; asignar b=c.
De lo contrario, asignar a=c.
Repetir hasta que ∣b−a∣/2<tolerancia.

El método siempre converge, aunque puede ser más lento que otros métodos (como Newton-Raphson).

💻 Código completo en Java 21

import java.util.Scanner;
import java.util.function.DoubleUnaryOperator;

public class BiseccionInteractiva {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("Método de Bisección");
        System.out.println("Función fija: f(x) = x^3 - x - 2");

        System.out.print("Ingrese el límite inferior (a): ");
        double a = sc.nextDouble();

        System.out.print("Ingrese el límite superior (b): ");
        double b = sc.nextDouble();

        System.out.print("Ingrese la tolerancia (ej. 1e-6): ");
        double tol = sc.nextDouble();

        System.out.print("Ingrese el número máximo de iteraciones: ");
        int maxIter = sc.nextInt();

        DoubleUnaryOperator f = x -> Math.pow(x, 3) - x - 2;

        if (f.applyAsDouble(a) * f.applyAsDouble(b) >= 0) {
            System.out.println("Error: f(a) y f(b) deben tener signos opuestos.");
            return;
        }

        double raiz = biseccion(f, a, b, tol, maxIter);
        System.out.println("Raíz aproximada: " + raiz);
    }

    public static double biseccion(DoubleUnaryOperator f, double a, double b, double tol, int maxIter) {
        double c = a;
        int iter = 0;

        while ((b - a) / 2 > tol && iter < maxIter) {
            c = (a + b) / 2;
            double fc = f.applyAsDouble(c);

            if (fc == 0.0) break;
            else if (f.applyAsDouble(a) * fc < 0) b = c;
            else a = c;

            iter++;
        }

        System.out.printf("Iteraciones realizadas: %d%n", iter);
        return (a + b) / 2;
    }
}

🔍 Explicación línea por línea

Scanner permite al usuario ingresar valores desde consola.

DoubleUnaryOperator define una función de tipo f(x)

Se usa Math.pow(x, 3) - x - 2 como función ejemplo (cuya raíz real es ≈ 1.52138).

Se validan los signos de f(a) y f(b) antes de iniciar.

En el ciclo while, el programa reduce el intervalo hasta cumplir la tolerancia o alcanzar el número máximo de iteraciones.

El método devuelve el punto medio del último intervalo como la raíz aproximada.

🧩 Ejemplo de ejecución

Método de Bisección
Función fija: f(x) = x^3 - x - 2
Ingrese el límite inferior (a): 1
Ingrese el límite superior (b): 2
Ingrese la tolerancia (ej. 1e-6): 1e-6
Ingrese el número máximo de iteraciones: 100
Iteraciones realizadas: 20
Raíz aproximada: 1.52138

📈 Ventajas y limitaciones

Ventajas:

• Convergencia garantizada si f(a)f(a)f(a) y f(b)f(b)f(b) tienen signos opuestos.

• Implementación simple y estable.

Limitaciones:

• Lento en comparación con métodos derivados (Newton, Secante).

• Solo encuentra una raíz por intervalo.

• Requiere conocer dos puntos iniciales donde la función cambie de signo.

🧪 Conclusión

El método de bisección es ideal para introducirse en los algoritmos de búsqueda de raíces. Aunque no es el más rápido, su certeza de convergencia lo convierte en una herramienta confiable para cualquier ingeniero, matemático o desarrollador que trabaje con problemas numéricos.