Aprende Java Aprende Php Aprende C++ Aprende HTML 5 Aprende JavaScript Aprende JSON Aprende MySQL Aprende SQLServer Aprende Visual Basic 6 Aprende PostgreSQL Aprende SQLite Aprende Redis Aprende Kotlin Aprende XML Aprende Linux VSC Aprende Wordpress Aprende Laravel Aprende VueJS Aprende JQuery Aprende Bootstrap Aprende Netbeans Aprende Android
Sigueme en Facebook Sigueme en Twitter Sigueme en Instagram Sigueme en Youtube Sigueme en TikTok Sigueme en Whatsapp
Home / Ingenieria de Sistemas / Método de la Regla Falsa o Regula Falsi

Método de la Regla Falsa o Regula Falsi

Por jc mouse lunes, junio 13, 2016

Este método, también conocido como método de interpolación lineal, 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.

regla falsa

En este método el nuevo valor de prueba se encuentra por interpolación lineal entre dichos límites, tal como se muestra en la figura de arriba. Para repetir el proceso se debe ubicar el segmento donde se encuentra la solución y repetir el proceso en ese nuevo segmento, prosiguiendo de esa manera hasta que se encuentra la solución, es decir hasta que el valor de la función sea cercano a cero o hasta que los dos últimos valores de prueba sean aproximadamente iguales.

La ecuación de la recta que pasa por los puntos (x1,y1) − (x2,y2) es:

interpolacion metodos

En la intersección con la recta «y=0» se cumple que el valor de «x» es igual al nuevo valor de prueba «x3», es decir:

regula falsi

Por ejemplo para hallar la solución de la siguiente ecuación x^3 – 2x^2 + 3x -8 tenemos:

import java.math.BigDecimal;

/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class Regula_Falsi {
    
    public Regula_Falsi(){}
    
    /**
     * Función a resolver
     * @param x valor de incognita
     * @return double
     */
    public double fx(double x){
               //x^3 - 2x^2 + 3x -8        
        return Math.pow(x, 3) - 2*Math.pow(x, 2) + 3*x - 8; 
    }
    
    /**
     * @param x1 Limite inferior
     * @param x2 Limite superior
     * @param iterations numero de iteraciones
     * @param err Error permitido
     * @return String resultado encontrado
     *                NULL en caso de encontrar algun error
     *                EMPTY en caso de no hallar convergencia al limite de iteraciones permitidas
     */
    public String resolver(double x1, double x2, int iterations, double err){
        
        int numDec=5;
        
        double x3, y3;
        double xp=x1;
        double y1=fx(x1);
        double y2=fx(x2);   
        
        //Valores iniciales
        System.out.println( " x1 = " + round(x1,numDec));
        System.out.println( " x2 = " + round(x2,numDec));
        System.out.println( " y1: fx("+x1+")= " + round(y1,numDec));
        System.out.println( " y2: fx("+x2+")= " + round(y2,numDec));
        
        for(int i=1; i<=iterations;i++){            
            System.out.println("Iteración #"+i);
            if ( (y2-y1) == 0 ){
               System.err.println("Error: no converge x=NaN; iteración="+i);
               return null;
            }
            
            x3=(y2*x1-y1*x2)/(y2-y1);
            System.out.println(" x3 = (y2*x1-y1*x2)/(y2-y1)");
            System.out.println(" x3 = ((" + round(y2,numDec)+")*("+round(x1,numDec)+")-("+round(y1,numDec)+")*("+round(x2,numDec)+"))/(("+round(y2,numDec)+")-("+round(y1,numDec)+")) = " + round(x3,numDec) );
            
            System.out.println("Error |"+round(xp,numDec)+"/"+round(x3,numDec)+"-1|<"+round(err,numDec)  + "  " + (Math.abs(xp/x3-1)<err));
            if (Math.abs(xp/x3-1)<err){                
                System.out.println(round(Math.abs(xp/x3-1),numDec)+"<"+round(err,numDec) + " -> termina programa");
                return "Iteración:" + i + " Valor x=" + String.valueOf(x3);
            }
            
            y3 = fx(x3); 
            
            System.out.println(" y1 = " + round(y1,numDec));
            System.out.println(" y3 = fx(x3) = fx("+round(x3,numDec)+") = " + round(y3,numDec));
            System.out.println(" y1*y3 < 0 " + (y1*y3 < 0));
            if (y1*y3<0) {
                System.out.println("   x2=x3=" + round(x3,numDec));
                System.out.println("   y2=y3=" + round(y3,numDec));
                x2=x3;
                y2=y3;
            } else {
                System.out.println("   x1=x3=" + round(x3,numDec));
                System.out.println("   y1=y3=" + round(y3,numDec));
                x1=x3;
                y1=y3;
            }
            xp=x3;
        }
        return "";
        
    }
    
    /**
     * Redondea un numero al inmediato superior
     * @param valor numero a redondear
     * @param decimales cantidad de decimales a mostrar
     * @return double numero redondeado
     */
    private double round(double valor, int decimales){
        BigDecimal valueBD = new BigDecimal(valor);
        valueBD = valueBD.setScale(decimales, BigDecimal.ROUND_HALF_UP);
        return valueBD.doubleValue();
    }
        
    public static void main(String[] args){
        Regula_Falsi regula_Falsi = new Regula_Falsi();        
        //String res = regula_Falsi.resolver(2.2, 6.5, 20, 0.0003);
        String res = regula_Falsi.resolver(2.2, 2.5, 20, 0.0003);
        System.out.println(res);
    }
}

Ejecutamos y tenemos en consola:

run:
 x1 = 2.2
 x2 = 2.5
 y1: fx(2.2)= -0.432
 y2: fx(2.5)= 2.625
Iteración #1
 x3 = (y2*x1-y1*x2)/(y2-y1)
 x3 = ((2.625)*(2.2)-(-0.432)*(2.5))/((2.625)-(-0.432)) = 2.24239
Error |2.2/2.24239-1|<3.0E-4  false
 y1 = -0.432
 y3 = fx(x3) = fx(2.24239) = -0.05398
 y1*y3 < 0 false
   x1=x3=2.24239
   y1=y3=-0.05398
Iteración #2
 x3 = (y2*x1-y1*x2)/(y2-y1)
 x3 = ((2.625)*(2.24239)-(-0.05398)*(2.5))/((2.625)-(-0.05398)) = 2.24758
Error |2.24239/2.24758-1|<3.0E-4  false
 y1 = -0.05398
 y3 = fx(x3) = fx(2.24758) = -0.00654
 y1*y3 < 0 false
   x1=x3=2.24758
   y1=y3=-0.00654
Iteración #3
 x3 = (y2*x1-y1*x2)/(y2-y1)
 x3 = ((2.625)*(2.24758)-(-0.00654)*(2.5))/((2.625)-(-0.00654)) = 2.24821
Error |2.24758/2.24821-1|<3.0E-4  true
2.8E-4<3.0E-4 -> termina programa
Iteración:3 Valor x=2.2482118149584385

Como nuestros puntos x1 y x2 son muy cercanos a la solución, no tendremos muchas iteraciones, en este caso solo 4, y x=2.2482118149584385

Tags

Artículos similares

Tink biblioteca criptográfica de Google

Tink es una biblioteca de cifrado desarrollada por un grupo de criptógrafos e ingenieros de seguridad de Google lanzado[...]

Distribución de escaños con el método D’Hondt caso práctico (Bolivia)

El sistema D’Hondt creado por el jurista belga Victor d’Hondt en 1878, es un método de promedio mayor para a[...]

Formateo de registros en Excel con JExcel

Tenia un problema, me pasaron unos archivos excel con unos cientos de registros (ver imagen más abajo) que exportaron de[...]

Búsqueda dinámica en JList

Un JList nos permite almacenar objetos en una lista y mostrarlos gráficamente en una serie vertical en el cual el usuari[...]

Adios al dd(): Realiza debugging de forma ordenada con LaraDumps

Si desarrollas en Laravel, conoces el ritual de escribir dd($variable), refrescar el navegador, analizar los datos, borr[...]

TextInput – Material Design

TextInput es una caja de texto que implementa el estilo de Material Design popular en dispositivos móviles, pero este sw[...]