Ejercicios, raíces de una ecuación

Raíces de una ecuación

Procedimiento del punto medio

Obtener el valor de las raíces de la ecuación

x³-7x²+14x-6=0 en los siguientes intervalos: [0, 1], [1, 3.2], [3.2, 4]

Solución

public abstract class Ecuacion {
    protected static final double CERO=1e-10;
    protected static final double ERROR=0.001;
    protected final int MAXITER=200;

    public double puntoMedio(double a, double b) throws RaizExcepcion{
        double m, ym;
        int iter=0;
        do{
            m=(a+b)/2;
            ym=f(m);
            if(Math.abs(ym)<CERO)           break;
            if(Math.abs((a-b)/m)<ERROR)     break;

            if((f(a)*ym)<0)     b=m;
            else                a=m;
            iter++;
        }while(iter<MAXITER);
        if(iter==MAXITER){
            throw new RaizExcepcion("No se ha encontrado la raíz");
        }
        return m;
    }

    abstract public double f(double x);
}

class RaizExcepcion extends Exception {
  public RaizExcepcion(String s) {
         super(s);
  }
}
public class Funcion1 extends Ecuacion{
    public double f(double x){
        return (x*x*x-7*x*x+14*x-6);
    }
}

public class MyClass1 {

    public static void main(String[] args){

      try{
          Ecuacion e=new Funcion1();
          double raiz=e.puntoMedio(0, 1.0);
          System.out.println(raiz);
          raiz=e.puntoMedio(1.0, 3.2);
          System.out.println(raiz);
          raiz=e.puntoMedio(3.2, 4.0);
          System.out.println(raiz);

       }catch(RaizExcepcion ex){
          System.out.println(ex.getMessage());
      }

  }
}

Comprobar que las raíces obtenidas coinciden con las calculadas a partir de las fórmulas de las raíces de una ecuación cúbica.

Solución

public class MyClass1 {

    public static void main(String[] args){
       //x^3+ax^2+bx+c=0
       double a=-7;
       double b=14;
       double c=-6;

       double R=(2*a*a*a-9*a*b+27*c)/54;
       double Q=(a*a-3*b)/9;
       if((R*R)<(Q*Q*Q)){
        //Para raíces reales
          double zeta=Math.acos((R/Math.sqrt(Math.pow(Q, 3))));
          double x1=-2*Math.sqrt(Q)*Math.cos(zeta/3)-a/3;
          double x2=-2*Math.sqrt(Q)*Math.cos((zeta+2*Math.PI)/3)-a/3;
          double x3=-2*Math.sqrt(Q)*Math.cos((zeta-2*Math.PI)/3)-a/3;
          System.out.println("x1="+x1+", x2="+x2+" y x3="+x3);
       }else{
        //Para raíces complejas
           int sgn=(R>0)?1:-1;
           double A=-sgn*Math.pow((Math.abs(R)+Math.sqrt(R*R-Q*Q*Q)),1.0/3);
           double B=(A==0)? 0:(Q/A);
           double x1= A+B-a/3;
           double RE=-(A+B)/2-a/3;
           double IM=Math.sqrt(3)*(A-B)/2;
           System.out.println("x1="+x1+", x2=("+RE+","+Math.abs(IM)+") y
             x3=("+RE+",-"+Math.abs(IM)+")");
       }
   }
}

Representar gráficamente la función

y= x³-7x²+14x-6

en el intervalo [-1, 5] señalando las abscisas x que hacen y=0

Solución

import java.awt.*;
import java.applet.*;

public class Applet1 extends Applet {

final double[] raices={0.586, 3.414, 3.0};

 public void init() {
//establece el color se fondo del applet
   setBackground(Color.white);
 }

 public void paint(Graphics g){
//ancho y alto del applet
   int wAlto=getSize().height;
   int wAncho=getSize().width;
//dimensiones de los caracteres
    int cAlto=g.getFontMetrics().getHeight();
    int cAncho=g.getFontMetrics().stringWidth("0");
//orígenes y escalas
   int orgY=wAlto/2;
  double escalaX=(double)(wAncho-2*cAncho)/6;
  double escalaY=(double)(wAlto-2*cAncho)/10;
  int orgX=cAncho+(int)(escalaX);

   g.setColor(Color.black);
//ejes
   g.drawLine(orgX-15*cAncho, orgY, wAncho, orgY);
   g.drawLine(orgX, 0, orgX, wAlto-cAlto);
   int x1, y1;
//divisiones del eje horizontal
   String texto;
   for(int i=-1; i<=5; i++){
       x1=orgX+(int)(i*escalaX);
       g.drawLine(x1, orgY, x1, orgY+cAncho);
       texto=String.valueOf(i);
       g.drawString(texto, x1-g.getFontMetrics().stringWidth(texto)/2, orgY+cAlto+cAncho);
       if(i==5) break;
       for(int j=1; j<10; j++){
               x1=orgX+(int)((i+(double)j/10)*escalaX);
               g.drawLine(x1, orgY, x1, orgY+cAncho/2);
               if (j==5)  g.drawLine(x1, orgY, x1, orgY+3*cAncho/4);
          }

   }
//divisiones del eje vertical
  for(int i=-5; i<=5; i++){
       y1=orgY-(int)(i*escalaY);
       g.drawLine(orgX, y1, orgX-cAncho, y1);
       texto=String.valueOf(i);
       g.drawString(texto, orgX-cAncho-g.getFontMetrics().stringWidth(texto), y1+cAlto/4);
  }
//gráfica de la función
   x1=orgX+(int)(-1*escalaX);
   y1=orgY-(int)(escalaY*f(-1));
   int x2, y2;
   g.setColor(Color.blue);
   for(double x=-1.0; x<5; x+=0.05){
       x2=orgX+(int)(escalaX*x);
       y2=orgY-(int)(escalaY*f(x));
        g.drawLine(x1, y1, x2, y2);
       x1=x2; y1=y2;
   }
//señala las raíces
    g.setColor(Color.red);
    for(int i=0; i<raices.length; i++){
      x1=orgX+(int)(escalaX*raices[i]);
      g.fillOval(x1-2, orgY-2, 4, 4);
    }
}
 double f(double x){
   return(x*x*x-7*x*x+14*x-6);
 }

}

Obtener las tres raíces reales de la ecuación mediante el procedimiento del punto medio para raíces míltiples

Solución

public abstract class Ecuacion {
    protected static final double CERO=1e-10;
    protected static final double ERROR=0.0001;
    protected final int MAXITER=100;
    protected final int MAXRAICES=20;
    protected double raices[]=new double[MAXRAICES];
    protected int iRaiz=0;

    protected double puntoMedio(double a, double b)throws RaizExcepcion{
        double m, ym;
        int iter=0;
        do{
            m=(a+b)/2;
            ym=f(m);
            if(Math.abs(ym)<CERO)           break;
            if(Math.abs((a-b)/m)<ERROR)     break;
            if((f(a)*ym)<0)     b=m;
            else                a=m;
            iter++;
        }while(iter<MAXITER);
        if(iter==MAXITER){
            throw new RaizExcepcion("No se ha encontrado una raíz");
        }
        return m;
 }
 protected void explorar(double xIni, double xFin, double dx){
      double y1, y2;
      iRaiz=0;
      y1=f(xIni);
      for(double x=xIni; x<xFin; x+=dx){
          y2=f(x+dx);
       //Uno de los extremos del intervalo es raíz
          if(Math.abs(y1)<CERO && iRaiz<MAXRAICES){
              raices[iRaiz++]=x;
              y1=y2;
              continue;
          }
       //no hay raíz en este intervalo
          if(y1*y2>=0.0){
              y1=y2;
              continue;
          }
       //hay una raíz en este intervalo
          if(iRaiz<MAXRAICES){
              try{
                  raices[iRaiz]=puntoMedio(x, x+dx);
                  iRaiz++;
              }catch(RaizExcepcion ex){
                  System.out.println(ex.getMessage());
              }
          }
          y1=y2;
      }
  }
  public double[] hallarRaices(double ini, double fin, double paso){
        explorar(ini, fin, paso);
        double solucion[]=new double[iRaiz];
        for(int i=0; i<iRaiz; i++){
            solucion[i]=(double)Math.round(raices[i]*1000)/1000;
        }
        return solucion;
  }
  abstract public double f(double x);
}


class RaizExcepcion extends Exception {
    public RaizExcepcion(String s) {
        super(s);
  }
}
public class Funcion extends Ecuacion {
    public double f(double x){
        return(x*x*x-7*x*x+14*x-6);
    }
}
public class MyClass1 {
           public static void main(String[] args) {
                   double[] raices=new Funcion().hallarRaices(-1, 5, 0.1);
                   System.out.print("Raíces de la ecuación");
                   for(int i=0; i<raices.length; i++){
                         System.out.print("  "+raices[i]);
                   }
                   System.out.println("");
           }
}

Método de aproximaciones sucesivas

La ecuación x³+4x²-10=0 tiene una raíz única en el intervalo [1, 2]. Hay muchas formas de convertirla en la forma x=f(x) mediante un simple manejo algebraico para aplicar el método de aproximaciones sucesivas.

Dependiendo de la forma de la función f(x) elegida el procedimiento converge o diverge. Descartando las segundas, unas expresiones convergen más rápidamente que otras hacia la raíz buscada.

Ejemplo.

$x = x - \frac{x^{3} + 4 x^{2} - 10}{3 x^{2} + 8 x}$

tómese x₀=1.5 como abscisa de partida

Encontrar otras expresiones de la función f(x) que converjan hacia la raíz buscada.

Solución

public abstract class Ecuacion {
    protected static final double ERROR=0.0001;

    public double raiz(double x0){
        double x1;
        while(true){
            x1=f(x0);
            if(Math.abs(x1-x0)<ERROR)   break;
            x0=x1;
        }
        return x0;
    }

    abstract public double f(double x);
}
public class Funcion extends Ecuacion{
    public double f(double x){
        //return Math.pow(10-4*x*x,1.0/3.0); //Con esta expresión no converge
        return (x-(x*x*x+4*x*x-10)/(3*x*x+8*x));
        //return (Math.sqrt((10-x*x*x)/4));
    }
}
public class MyClass1 {
 public static void main(String[] args) {
        Funcion f1=new Funcion();
        System.out.println("solucion "+f1.raiz(1.5));
       // System.out.println("solucion1 "+f1.raiz(0.9));
  }
}

Sistema de ecuaciones

Calcular las raíces del sistema

f₁(x,y)=2x²-xy-5x-1=0

f₂(x,y)=x+3log₁₀x-y²=0

Trácese los gráficos de f₁(x,y)=0 y f₂(x,y)=0, en los intervalos x[0, 4], y[0, 2.5] para obtener los valores aproximados del punto (x, y) de intersección.

Solución

public class Applet1 extends Applet {

  final double x0= 3.81;
  final double y0=2.36;

 public void init() {
//establece el color se fondo del applet
   setBackground(Color.white);
 }

 public void paint(Graphics g){
//ancho y alto del applet
   int wAlto=getSize().height;
   int wAncho=getSize().width;
//dimensiones de los caracteres
    int cAlto=g.getFontMetrics().getHeight();
    int cAncho=g.getFontMetrics().stringWidth("0");
//orígenes
   int orgX=4*cAncho;
   int orgY=wAlto-cAncho-cAlto;
//escala vertical y horizontal
  double escalaX=(double)(wAncho-orgX-2*cAncho)/4;
  double escalaY=(double)(orgY)/2.5;
   g.setColor(Color.black);
//ejes
   g.drawLine(orgX, orgY, wAncho, orgY);
   g.drawLine(orgX, 0, orgX, wAlto);
   int x1, y1;
//divisiones del eje horizontal
   String texto;
   for(int i=0; i<=4; i++){
       x1=orgX+(int)(i*escalaX);
       g.drawLine(x1, orgY, x1, orgY+cAncho);
       texto=String.valueOf(i);
       g.drawString(texto, x1-g.getFontMetrics().stringWidth(texto)/2, orgY+cAlto+cAncho);
       if(i==5) break;
       for(int j=1; j<10; j++){
               x1=orgX+(int)((i+(double)(j)/10)*escalaX);
               g.drawLine(x1, orgY, x1, orgY-cAncho/2);
               if(j==5)  g.drawLine(x1, orgY, x1, orgY-3*cAncho/4);
          }

   }
//divisiones del eje vertical
  for(int i=0; i<=3; i++){
       y1=orgY-(int)(i*escalaY);
       g.drawLine(orgX, y1, orgX-cAncho, y1);
       texto=String.valueOf(i);
       g.drawString(texto, orgX-cAncho-g.getFontMetrics().stringWidth(texto), y1+cAlto/4);
       for(int j=1; j<10; j++){
               y1=orgY-(int)((i+(double)(j)/10)*escalaY);
               g.drawLine(orgX, y1, orgX-cAncho/2, y1);
               if(j==5)  g.drawLine(orgX, y1, orgX-3*cAncho/4, y1);
          }
  }
//gráficas de las funciones
   x1=orgX;
   y1=orgY-(int)(escalaY*f(0.01));
   int x2, y2;
   g.setColor(Color.blue);
   for(double x=0.01; x<4; x+=0.01){
       x2=orgX+(int)(escalaX*x);
       y2=orgY-(int)(escalaY*f(x));
       g.drawLine(x1, y1, x2, y2);
       x1=x2; y1=y2;
   }
   x1=orgX;
   y1=orgY-(int)(escalaY*g(0.01));
   g.setColor(Color.red);
   for(double x=0.01; x<4; x+=0.01){
       x2=orgX+(int)(escalaX*x);
       y2=orgY-(int)(escalaY*g(x));
       g.drawLine(x1, y1, x2, y2);
       x1=x2; y1=y2;
   }
   g.setColor(Color.black);
   x1=orgX+(int)(escalaX*x0);
   y1=orgY-(int)(escalaY*y0);
   g.fillOval(x1-2, y1-2, 4, 4);
}
 double f(double x){
   return((2*x*x-5*x-1)/x);
 }
 double g(double x){
   return Math.sqrt(x+3*Math.log(x)/Math.log(10));
 }

}

Despejar x en la primera ecuación, x=g₁(x, y)
Despejar y en la segunda ecuación, y=g₂(x, y)

Aplicar el procedimiento de las aproximaciones sucesivas

x_n+1=g₁(x_n, y_n)

y_n+1=g₂(x_n, y_n)

Para obtener las raíces (x, y) buscadas

Comprobar si resulta más conveniente utilizar el procedimiento modificado de Seidel

x_n+1=g₁(x_n, y_n)

y_n+1=g₂(x_n+1, y_n)

Solución

public class Punto {
  public double x;
  public double y;
  public Punto(double x, double y) {
    this.x=x;
    this.y=y;
  }
} 
public abstract class Ecuacion {
    protected static final double ERROR=0.001;

    public Punto raiz(double x0, double y0){
        double x1, y1;
        while(true){
            x1=f(x0, y0);
            y1=g(x0, y0);
            if(Math.abs(x1-x0)<ERROR && Math.abs(y1-y0)<ERROR)   break;
            x0=x1;
            y0=y1;
        }
        return new Punto(x0, y0);
    }

    abstract public double f(double x, double y);
    abstract public double g(double x, double y);
}
public class Funcion extends Ecuacion{
    public double f(double x, double y){
        double z=Math.sqrt((x*y+5*x+1)/2);
        return z;
    }
    public double g(double x, double y){
        double z=Math.sqrt(x+3*Math.log(x)/Math.log(10));
        return z;
    }
}
public class MyClass1 {
  public static void main(String[] args) {
        Punto raiz=new Funcion().raiz(1.0, 1.0);
        System.out.println("x: "+raiz.x+", y: "+raiz.y);
  }
}

Procedimiento gráfico

Representar la función y=tan(x) en el intervalo [0, 5π/2]

Representar la recta y=x

Determinar los puntos de intersección, es decir, las raíces de la ecuación x=tan(x)

Véase la página Difracción producida por una rendija

Solución

import java.awt.*;
import java.applet.*;

public class Applet1 extends Applet {
 public void init() {
//establece el color se fondo del applet
   setBackground(Color.white);
 }

 public void paint(Graphics g){
//ancho y alto del applet
   int wAlto=getSize().height;
   int wAncho=getSize().width;
//dimensiones de los caracteres
    int cAlto=g.getFontMetrics().getHeight();
    int cAncho=g.getFontMetrics().stringWidth("0");
//orígenes
   int orgX=3*cAncho;
   int orgY=wAlto/2;
//escala vertical y horizontal
  double escalaX=(double)(wAncho-orgX-2*cAncho)/8;
  double escalaY=(double)(wAlto-2*cAncho)/20;
   g.setColor(Color.black);
//ejes
   g.drawLine(orgX-15*cAncho, orgY, wAncho, orgY);
   g.drawLine(orgX, 0, orgX, wAlto-cAlto);
   int x1, y1;
//divisiones del eje horizontal
   String texto;
   for(int i=0; i<=8; i++){
       x1=orgX+(int)(i*escalaX);
       g.drawLine(x1, orgY, x1, orgY+cAncho);
       texto=String.valueOf(i);
       g.drawString(texto, x1-g.getFontMetrics().stringWidth(texto)/2, orgY+cAlto+cAncho);
       if(i==8) break;
       for(int j=1; j<10; j++){
               x1=orgX+(int)((i+(double)(j)/10)*escalaX);
               g.drawLine(x1, orgY, x1, orgY+cAncho/2);
               if (j==5)  g.drawLine(x1, orgY, x1, orgY+3*cAncho/4);
          }
   }
//divisiones del eje vertical
  for(int i=-10; i<=10; i+=2){
       y1=orgY-(int)(i*escalaY);
       g.drawLine(orgX, y1, orgX-cAncho, y1);
       texto=String.valueOf(i);
       g.drawString(texto, orgX-cAncho-g.getFontMetrics().stringWidth(texto), y1+cAlto/4);
  }
//gráfica de la función
   x1=orgX;
   y1=orgY;
   int x2, y2;
   g.setColor(Color.blue);
   for(double x=0.0; x<8; x+=0.05){
       x2=orgX+(int)(escalaX*x);
       y2=orgY-(int)(escalaY*Math.tan(x));
       g.drawLine(x1, y1, x2, y2);
       x1=x2; y1=y2;
   }
   g.setColor(Color.red);
   x1=orgX;
   y1=orgY;
   x2=orgX+(int)(escalaX*8);
   y2=orgY-(int)(escalaY*8);
   g.drawLine(x1, y1, x2, y2);

  }
}

Obtener las raíces aplicando el procedimiento numérico del punto medio para raíces múltiples en el intervalo (-0.5, 8). Si calculamos las raíces de la ecuación y=x-tan(x) obtenemos seis raíces, de las cuales 3 no son correctas y corresponden a la intersección de la recta y=x con las asíntotas verticales de tan(x) en π/2, 3π/2 y 5π/2.En cambio, si calculamos las raíces de la ecuación y=x·cos(x)-sin(x) obtenemos las tres raíces buscadas en dicho intervalo.

Solución

//copiar la clase Ecuacion para raíces múltiples del primer ejercicio

public class Funcion extends Ecuacion {
    public double f(double x){
        return(x*Math.cos(x)-Math.sin(x));
    }
}
public class MyClass1 {
           public static void main(String[] args) {
                   double[] raices=new Funcion().hallarRaices(-0.5, 8, 0.1);
                   System.out.print("Raíces de la ecuación");
                   for(int i=0; i<raices.length; i++){
                         System.out.print("  "+raices[i]);
                   }
                   System.out.println("");
           }
}

Procedimiento de Newton-Raphson

Programar el procedimiento de Newton-Raphson

$x_{n} = x_{n - 1} - \frac{f (x_{n - 1})}{f' (x_{n - 1})} n \geq 1$

El procedimiento fracasará si no se encuentra la raíz buscada después de N iteracciones

Aplicar este procedimiento para calcular las raíces de la ecuación

x³-2x²-5=0 en el intervalo [1, 4]. Calcular las raíces reales de esta ecuación cúbica con el programa anterior para verificar que el procedimiento está bien programado.

Solución

public abstract class Newton {
   final double ERROR=0.001;
   final int MAXITER=100;

  double resolver(double a, double b){
        double rtn=0.5*(a+b);
        double dx;
        for(int j=1;j<=MAXITER;j++){
            dx=f(rtn)/df(rtn);
            rtn-=dx;
            if ((a-rtn)*(rtn-b) < 0.0)
                System.out.println("Jumped out of brackets in resolver");
            if (Math.abs(dx) <ERROR) return rtn;
        }
        System.out.println("Maximum number of iterations exceeded in resolver");
        return 0.0;
    }
        abstract public double f(double x);
        abstract public double df(double x);
}
public class Funcion extends Newton{
  public double f(double x){
      return(x*x*x-2*x*x-5);
  }
  public double df(double x){
      return(3*x*x-4*x);
  }
}
public class MyClass1 {
      public static void main(String[] args){
          Newton n=new Funcion();
          System.out.println("raíz "+n.resolver(1, 4));
      }
}

Procedimiento de Newton-Raphson mejorado

Aplicar el procedimiento de Newton-Raphson mejorado, combinación con el método del punto medio.para calcular las raíces de las ecuaciones

x³-2x²-5=0 en el intervalo [1, 4]
x-cosx=0 en el intervalo [0, π/2]
sinx-e^-x=0 en los intervalos [0,1], [3, 4], [6, 7]

Press W. H., Teukolsky S. A., Vetterling W. T., Flannery B. P. Numerical Recipes in C, Second edition. Root Finding and Nonlinear Sets of Equations. Sección 9.4. Newton-Raphson Method Using Derivative. Cambridge University Press. Código en C adaptado por el autor al lenguaje Java

Solución

public abstract class Newton {
   final double ERROR=0.001;
   final int MAXITER=100;

  double resolver(double a, double b){
        double xl, xh, rts, temp;
        double fl=f(a);
        double fh=f(b);
        if((fl>0.0&&fh>0.0)||(fl<0.0&&fh<0.0))
            System.out.println("Root must be bracketed in resolver");
        if(fl==0)return a;
        if(fh==0)return b;
        if(fl<0.0){
            xl=a;
            xh=b;
        }else {
            xh=a;
            xl=b;
        }
        rts=0.5*(a+b);
        double dxold=Math.abs(b-a);
        double dx=dxold;
        double f=f(rts);
        double df=df(rts);
        for(int j=1;j<=MAXITER;j++){
            if(((rts-xh)*df-f)*((rts-xl)*df-f)>=0.0||
            		(Math.abs(2.0*f)>Math.abs(dxold*df))){
                dxold=dx;
                dx=0.5*(xh-xl);
                rts=xl+dx;
                if(xl==rts)return rts;
            }else{
                dxold=dx;
                dx=f/df;
                temp=rts;
                rts-=dx;
                if(temp==rts)return rts;
            }
            if(Math.abs(dx)<ERROR)return rts;
            f=f(rts);
            df=df(rts);
            if(f<0.0)    xl=rts;
            else        xh=rts;
        }
        System.out.println("Maximum number of iterations exceeded in resolver");
        return 0.0;
    }
        abstract public double f(double x);
        abstract public double df(double x);
}
public class Funcion extends Newton{
  public double f(double x){
      return(x*x*x-2*x*x-5);
  }
  public double df(double x){
      return(3*x*x-4*x);
  }
}
public class Funcion1 extends Newton{
  public double f(double x){
      return(Math.sin(x)-Math.exp(-x));
  }
  public double df(double x){
      return(Math.cos(x)+Math.exp(-x));
  }
}
public class Funcion2 extends Newton{
  public double f(double x){
      return(x-Math.cos(x));
  }
  public double df(double x){
      return(1+Math.sin(x));
  }
}
public class MyClass1 {
      public static void main(String[] args){
          Newton n=new Funcion();
          System.out.println("raíz "+n.resolver(1, 4));
          n=new Funcion1();
          System.out.println("raíz "+n.resolver(0, 1));
          System.out.println("raíz "+n.resolver(3, 4));
          System.out.println("raíz "+n.resolver(6, 7));
          n=new Funcion2();
          System.out.println("raíz "+n.resolver(0, Math.PI/2));
      }
}

Procedimiento de Van Wijngaarden–Dekker–Brent

Aplicar este procedimiento para calcular las raíces de las ecuaciones

x³-2x²-5=0 en el intervalo [1, 4]
x-cosx=0 en el intervalo [0, π/2]
sinx-e^-x=0 en los intervalos [0,1], [3, 4], [6, 7]

Press W. H., Teukolsky S. A., Vetterling W. T., Flannery B. P. Numerical Recipes in C, Second edition. Root Finding and Nonlinear Sets of Equations. Sección 9.3. Van Wijngaarden–Dekker–Brent Method. Cambridge University Press. Código en C adaptado por el autor al lenguaje Java

Solución

public abstract class Ecuacion {
    final int ITMAX=100; // Maximum allowed number of iterations.
    final double EPS=3.0e-8; // Machine floating-point precision.
    final double ERROR=0.001;
  public double  resolver(double x1, double x2){
      int iter;
      double a=x1,b=x2,c=x2,d=0.0,e=0.0,min1,min2;
      double fa=f(a),fb=f(b),fc,p,q,r,s,tol1,xm;
      if ((fa > 0.0 && fb > 0.0) || (fa < 0.0 && fb < 0.0))
          System.out.println("Root must be bracketed in zbrent");
      fc=fb;
      for (iter=1;iter<=ITMAX;iter++) {
          if ((fb > 0.0 && fc > 0.0) || (fb < 0.0 && fc < 0.0)) {
              c=a; //Rename a, b, c and adjust bounding interval  d
              fc=fa;
              e=d=b-a;
          }
          if (Math.abs(fc) < Math.abs(fb)) {
              a=b;
              b=c;
              c=a;
              fa=fb;
              fb=fc;
              fc=fa;
        }
        tol1=2.0*EPS*Math.abs(b)+0.5*ERROR; // Convergence check.
        xm=0.5*(c-b);
        if (Math.abs(xm) <= tol1 || fb == 0.0) return b;
        if (Math.abs(e) >= tol1 && Math.abs(fa) > Math.abs(fb)) {
            s=fb/fa; //Attempt inverse quadratic interpolation.
            if (a == c) {
                p=2.0*xm*s;
                q=1.0-s;
            } else {
                q=fa/fc;
                r=fb/fc;
                p=s*(2.0*xm*q*(q-r)-(b-a)*(r-1.0));
                q=(q-1.0)*(r-1.0)*(s-1.0);
            }
            if (p > 0.0) q = -q; //Check whether in bounds.
            p=Math.abs(p);
            min1=3.0*xm*q-Math.abs(tol1*q);
            min2=Math.abs(e*q);
            if (2.0*p < (min1 < min2 ? min1 : min2)) {
                e=d; // Accept interpolation.
                d=p/q;
            } else {
                  d=xm; //Interpolation failed, use bisection.
                  e=d;
            }
        } else { //Bounds decreasing too slowly, use bisection.
            d=xm;
            e=d;
        }
        a=b; //Move last best guess to a.
        fa=fb;
        if (Math.abs(d) > tol1) //Evaluate new trial root.
            b += d;
        else{
            int signo=(xm>0) ? 1 : -1;
            b+=(Math.abs(tol1)*signo);
        }
        fb=f(b);
    }
    System.out.print("Maximum number of iterations exceeded in zbrent");
    return 0.0; //Never get here.
  }
        abstract public double f(double x);
}
public class Funcion extends Ecuacion{
  public double f(double x){
      return(x*x*x-2*x*x-5);
  }
}
public class Funcion1 extends Ecuacion{
  public double f(double x){
      return(Math.sin(x)-Math.exp(-x));
  }
}
public class Funcion2 extends Ecuacion{
  public double f(double x){
      return(x-Math.cos(x));
  }
}
 public class MyClass1 {
      public static void main(String[] args){
          Ecuacion e=new Funcion();
          System.out.println("raíz "+e.resolver(1, 4));
          e=new Funcion1();
          System.out.println("raíz "+e.resolver(0, 1));
          System.out.println("raíz "+e.resolver(3, 4));
          System.out.println("raíz "+e.resolver(6, 7));
          e=new Funcion2();
          System.out.println("raíz "+e.resolver(0, Math.PI/2));
      }
}