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

base de datos multiple – parte II

Continuación del tutorial «Utiliza 2 bases de datos diferentes en una aplicación» La Interfaz frmSelected.java: Haciendo[...]

JTable con JCheckBox y celdas NULL

Me llego la siguiente duda por facebook que me pareció interesante: «Se quiere desarrollar una tabla en java que haga us[...]

MVC: Modelo, Vista y Controlador en PHP

EL patrón MVC (Model, View, Controller) o Modelo, Vista Controlador, es un tipo de diseño que separa en capas bien defin[...]

Animación de bicho feo en java2D

Java2d nos permite manipular imagenes y asi poder crear animaciones sencillas como muestra el siguiente video. Puedes de[...]

Conoce VAR lo nuevo de Java 10

Java ha ido evolucionando a pasos agigantados en los últimos años gracias al pedido de su comunidad global de programado[...]

Conectar java con Firebird

En este tutorial veremos la forma de conectarse a una base de datos de Firebird utilizando el lenguaje Java y el IDE Net[...]