Métodos Numéricos: Sustitución Directa

El Método de Sustitución Directa básicamente consiste en asumir un valor, reemplazar el mismo en la función despejada y emplear el resultado como nuevo valor de prueba. Repitiendo este procedimiento hasta que los valores asumido y calculado sean iguales en un determinado número de dígitos (en una precisión preestablecida).

No obstante se debe aclarar que  el método de sustitución directa no siempre encuentra la solución (no siempre converge). En ocasiones puede alejarse de la misma u oscilar entre dos o más valores.

El algoritmo es el siguiente

En el algoritmo, el proceso se lleva a cabo en un ciclo que termina cuando se alcanza la precisión o alternativamente la exactitud: |x1-y1| < err.

• La precisión es el número de dígitos que son correctos en el valor de la incógnita (en el resultado calculado) y se determina comparando los valores de la incógnita de dos iteraciones consecutivas.
• La exactitud es el número de dígitos que son correctos cuando se calcula el valor de la ecuación. La forma más sencilla de determinar la exactitud es igualar la ecuación a 0, entonces la exactitud es simplemente el número de ceros después del punto. Para determinar la exactitud en el algoritmo se compara el valor de la función igualada a cero, con el error predeterminado.

Como ya dijimos más arriba, este método a veces no encuentra la solución lo que nos llevaría a un ciclo infinito, para evitar esto se implementa un numero máximo de iteraciones tras los cuales el método retornaría «-1» para romper el ciclo.

Implementando el algoritmo en código java, tenemos:

/**
 * @see https://www.jc-mouse.net/
 * @author jc mouse
 */
public class SustitucionDirecta {
    
    /**
     * @param x1 Valor incial Ej. 3
     * @param err Error permitdo Ej. 1e-10
     * @param li Limite de iterraciones Ej. 100
     * @return double 
     */
    public double calcular(double x1, double err, double li){
        double y1;
        double c=1;
        while (true){
            y1 = g(x1);
            if (Math.abs(x1-y1)<err) 
                return y1;
            if (Math.abs(x1/y1-1)<err) 
                return y1;
            if (c==li)
                return -1;                            
            c++;
            x1=y1;
        }        
    }
    
    /**
     * Funcion a resolver
     * @param x incognita
     * @return double
     */
    private double g(double x){
        return Math.pow(52+3*Math.sqrt(x)-8*Math.pow(x,0.8),0.36);        
    }
    
}

En la clase, al declarar el método g(x), se escribe la ecuación que se busca resolver que para nuestro ejemplo es:

Y para resolver esa ecuación haríamos lo siguiente:

SustitucionDirecta sustitucionDirecta = new SustitucionDirecta();
double valor = sustitucionDirecta.calcular(3, 1e-10, 100);        
System.out.println(valor);

y por consola tenemos:

enjoy!!!