M�todos Indirectos

Veremos como se implementan computacionalmente m�todos para resolver la ecuaci�n f(x) = 0 tales como el m�todo de la Bisecci�n, Regula false, Secante,y Newton.

Implementando una interfaz para la funci�n

Todos los m�todos iterativos , requieren una funci�n f(x) para evaluar ciertos elementos de un intervalo. Esta funci�n puede ser simple o una extensi�n de otras clases, como lo es el m�todo evaluar(double t) de la clase Polinomio.

Para hacer flexible el uso de estas clases simples o compuestas, se declara una interfaz llamada Evaluar.

interface Evaluar
{
    double f (double x);	
}

Ejemplo de uso de la interfaz

Supongamos que vamos a buscar ra�ces de Polinomios de grado n. Ya que se cuenta con la clase Polinomio que permite crearlos mediante coeficientes reales, solamente tenemos que crear una clase derivada que implemente la interfaz Evaluar.

class EvalPolinomio extends Polinomio implements Evaluar
{
    public EvalPolinomio (double coef[ ])
    {
        super(coef);
    }
	
    public double f (double x)
    {
        return evaluar(x); 	
    }
}

En la mayor�a de los m�todos se pasar� como par�metro un objeto Evaluar, al m�todo encargado de calcular la ra�z.

La clase Biseccion, cuenta con un m�todo llamado raiz(Evaluar e) para realizar la tarea, por lo tanto si queremos pasar un polinomio, debemos hacer lo siguiente :

    /* creaci�n de un objeto Bisecci�n */
    Biseccion b = new Biseccion( );	
	
    /* coeficientes del polinomio (x-1)(x-2)(x+5) desarrollado */
	
    double coef[ ] = { 10.0 , -13.0 , 2.0 , 1.0  };
	
    /* creaci�n de un objeto de tipo Polinomio (extendido) */
		
    EvalPolinomio ep = new EvalPolinomio(coef);
	
    /* asignaci�n del intervalo de b�squeda */
		
    b.asignarDatos(0.0 , 1.8);
	
    /* evaluaci�n del polinimio para x = 1.5   y   x = 2.7 */
		
    System.out.println("f(1.5) : " + ep.f(1.5));
    System.out.println("f(2.7) : " + ep.f(2.7));
	
    /* se calcula la ra�z */
		
    System.out.println("raiz : " + b.raiz(ep));

Ahora bien, si queremos pasar una funci�n de prueba cualquiera, por ejemplo Exponencial de x menos x elevado a 5, declaramos una clase que implemente la interfaz correspondiente.

Ej :

class funcExp implements Evaluar
{
    public double f (double x)
    {
        return Math.exp(x) - Math.pow(x,5); 	
    }
}

class pruebaExp
{
    public static void main(String arg[ ])
    {
        Biseccion b = new Biseccion();	
		
        funcExp exp = new funcExp();
		
        b.asignarDatos(0.0,2.0);
		
        System.out.println("f(0.0) : " + exp.f(0.0));
        System.out.println("f(2.0) : " + exp.f(2.0));
		
        System.out.println("raiz : " + b.raiz(exp));
    }	
}

/* salida del programa : 

   f(0.0) = 1.0
   f(2.0) = -24.61094...
   raiz : 1.295868...

*/

M�todo de la Bisecci�n

Sea f : [a,b] y supongamos que f(a)* f(b) <= 0
Supongamos adem�s que existe una �nica ra�z t perteneciente al intervalo [a,b] tal que f(t) = 0

Algoritmo

Datos : a, b, EPSILON y f(x)

Paso 1) c = ( a + b ) / 2

Paso 2) SI ( b - c <= EPSILON ) ENTONCES
              raiz = c   y  fin
           SINO
               seguir

Paso 3) SI ( f(a) * f(c) <= 0)
               b = c
           SINO
               a = c

Paso 4) Volver a paso 1

Implementaci�n

La clase Bisecci�n consta de tres m�todos encargados de asignar el intervalo de b�squeda (asignarDatos), retornar el n�mero de iteraciones necesarias para encontrar la ra�z (numIteraciones) y finalmente el m�todo que aplica el algoritmo de la bisecci�n (raiz).

Para evitar un loop infinito, se incluye una constante que restringe el n�mero m�ximo de iteraciones que debieramos esperar (MAX_ITER).

class Biseccion 
{
    public static double EPSILON = 0.00005;
    public final static int MAX_ITER = 500; 
    
    private double a,b,c;
    
    private int cont;
    
    public void asignarDatos(double a , double b)
    {
        this.a = a;
        this.b = b;
        this.cont = 0;
    }
	
    public int numIteraciones( )
    {
        return cont;	
    }
	
    public double raiz( Evaluar e )
    {
        while(true)
        {
            c = (a + b) / 2;
			
            if( b - c <= EPSILON) break;	

            if ( f(a) * f(c) <= 0.0)
                b = c;
            else
                a = c;
        
            cont++;
            if (cont > MAX_ITER ) break;
        }	
		
        return c;
    } 
}

Programa de prueba

Se va a encontrar las ra�ces del polinomio : (x-3)(x+2)(x-1) mediante el m�todo de la bisecci�n , adem�s de realizar la evaluaci�n del intervalo de b�squeda y mostrar el n�mero de iteraciones que se realiz� en la b�squeda.

C�digo fuente

class pruebaBisecc
{
    public static void impResult(double a , double b , Biseccion bisecc , Evaluar e)
    {
        bisecc.asignarDatos(a,b);
        
        System.out.println("\n\tEvaluacion de intervalo : [ " + a + " , " + b + " ]\n");
        System.out.println("\tf(" + a + ") : " + e.f(a));
        System.out.println("\tf(" + b + ") : " + e.f(b));
		
        System.out.println("\traiz : " + bisecc.raiz(e));
        System.out.println("\tNumero de iteraciones : " + bisecc.numIteraciones());	
    }
	
    public static void main(String arg[ ])
    {
        Biseccion b = new Biseccion( );	
		
        /*  polinomio : (x-3)(x+2)(x-1) = 6 - 5x - 2x^2 + x^3 */
        double coef[ ] = { 6.0 , -5.0 , -2.0 , 1.0  };
		
        EvalPolinomio ep = new EvalPolinomio(coef);
		
        System.out.println("\n\tPolinomio : " + ep.toString("x"));
		
        impResult(1.8 , 3.9 , b , ep);
        impResult(-3.3 , -1.0 , b , ep);
        impResult(-0.2 , 1.6 , b , ep);
	
        System.out.println( );
    }	
}