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

Firebird iSQL – introducción

iSQL: Es una herramienta de linea de comandos que acompaña a Firebird, se encuentra en la carpeta BIN, sirve para realiz[...]

Pruebas instrumentadas con Espresso

Espresso es un framework de testing propiedad de Google que está dirigido a desarrolladores que creen que las pruebas au[...]

Introducción a Scene Builder y MVC (Parte II)

Segunda parte del tutorial [Introducción a Scene Builder y MVC (Parte I)]. En esta segunda parte, completaremos el diseñ[...]

Trabajando con varios Activitys

Hasta este momento utilizamos un solo Activity para desarrollar nuestras aplicaciones, sin embargo es común que las apli[...]

Leer Código QR desde un archivo de imagen

Los códigos QR del inglés Quick Response Code o código de respuesta rápida es un tipo de código para el almacenamiento d[...]

Generador de códigos QR (Quick Response)

En este tutorial aprenderemos a crear nuestra propia aplicación java para generar códigos QR. ¿Que es un Código QR? «Un[...]