Método de la falsa posición

En cálculo numérico, el método de regula falsi (regla del falso) o falsa posición es un método iterativo de resolución numérica de ecuaciones no lineales. El método combina el método de bisección y el método de la secante.

El método

Las primeras dos iteraciones de regula falsi. La curva roja muestra la función f; las líneas azules, las secantes.

Como en el método de bisección, se parte de un intervalo inicial [a₀,b₀] con f(a₀) y f(b₀) de signos opuestos, lo que garantiza que en su interior hay al menos una raíz (véase Teorema de Bolzano). El algoritmo va obteniendo sucesivamente en cada paso un intervalo más pequeño [a_k, b_k] que sigue incluyendo una raíz de la función f.
A partir de un intervalo [a_k, b_k] se calcula un punto interior c_k:

Dicho punto es la intersección de la recta que pasa por (a,f(a_k)) y (b,f(b_k)) con el eje de abscisas (igual a como se hace en el método de la secante).
Se evalúa entonces f(c_k). Si es suficientemente pequeño, c_k es la raíz buscada. Si no, el próximo intervalo [a_k+1, b_k+1] será:

• [a_k, c_k] si f(a_k) y f(c_k) tienen signos opuestos;
• [c_k, b_k] en caso contrario.

Análisis del método

Se puede demostrar que bajo ciertas condiciones el método de la falsa posición tiene orden de convergencia lineal, por lo que suele converger más lentamente a la solución de la ecuación que el método de la secante, aunque a diferencia de en el método de la secante el método de la falsa posición siempre converge a una solución de la ecuación.
El algoritmo tiene el inconveniente de que si la función es convexa o cóncava cerca de la solución, el extremo del intervalo más alejado de la solución queda fijo variando únicamente el más cercano, convergiendo muy lentamente.
Un ejemplo de este fenómeno se da en la función:

comenzando con [−1,1]. El extremo izquierdo del intervalo, −1, nunca cambia; el extremo derecho se aproxima a 0 linealmente.
La situación en que el método falla es fácil de detectar (el mismo extremo del intervalo se elige dos veces seguidas) y fácil de corregir eligiendo un c_k diferente, como:

o

restándole peso a uno de los extremos del intervalo para obligar a que el próximo c_k ocurra de ese lado de la función.
El factor 2 usado arriba, garantiza una convergencia superlineal (asintóticamente, el algoritmo ejecuta dos pasos normales por cada paso modificado). Hay otras formas que dan incluso mejores tasas de convergencia. El ajuste mencionado arriba, y otras modificaciones similares se conocen como Algoritmo Illinois. Ford resume y analiza las variantes superlineales del método regula falsi modificado. A juzgar por la bibliografía, estos métodos eran bien conocidos en los años 1970 pero han sido olvidados en los textos actuales.

Algoritmo

JAVA

/**
 *
 * @author fredy mosquera lemus
 */
public class ReglaFlasa {
    /**
     * Este metodo crea un funcion a la cual se le aplicara el método de
     * regla falsa teniendo como parametro de entrada un double x, el cual
     * sirve para la construccion de la funcion dentro del metodo
     * @param x
     * @return
     */
    private double funcion(double x){
        return (x*x) - 3;
    }
    /**
     * Metodo de regla falsa
     * @param a
     * @param b
     * @param error
     * @return
     */
    public double metodoDeReglaFalsa(double a, double b, double error){
        double fa, fb,fc;
        double c = 0;
        if((funcion(a) * funcion(b) > 0)){
            System.out.println("Error en el intervalo inicial, para este intervalo" +
                    " no existen raices. ");
        }else{
            fa = funcion(a);
            fb = funcion(b);
            c = b - ((fb * (b -a ))/(fb - fa));
            fc = funcion(c);
            do{
                if((fa * fc) > 0){
                    a = c;
                    fa = funcion(a);
                    fb = funcion(b);
                     c = b - ((fb * (b -a ))/(fb - fa));
                    fc = funcion(c);
                }else if((fb * fc) > 0 ){
                    b = c;
                    fa = funcion(a);
                    fb = funcion(b);
                    c = b - ((fb * (b -a ))/(fb - fa));
                    fc = funcion(c);
 
                }
            }while(Math.abs(fc) > error);
 
        }
         return  c;
    }
 
}

guia
http://es.scribd.com/doc/5707211/Falsa-Posicion