ROMBERG

ROMBERG

CÓDIGO EN JAVA

La aplicación consta de tres clases. 
La clase "Funcion" se encarga de obtener el resultado de la formula digitada por el usuario.

import java.util.logging.Level; 
import java.util.logging.Logger; 
import javax.script.ScriptEngine; 
import javax.script.ScriptEngineManager; 
import javax.script.ScriptException; 


public class Funcion 
{ 
    ScriptEngineManager manager = new ScriptEngineManager(); 
    ScriptEngine engine = manager.getEngineByName("js" ); 
     
    String nodosFormula[]; 
    String nombreVariable; 
     
    public Funcion(String nodosFormula[], String nombreVariable) 
    { 
        this.nodosFormula= nodosFormula; 
        this.nombreVariable= nombreVariable; 
    } 
     
     
    public double evaluar(double valorX) 
    { 
        double resultado= 0; 
         
        String nodosFormulaAuxiliar[]= new String[nodosFormula.length]; 
        for(int i=0;i<nodosFormulaAuxiliar.length;i++) 
        { 
            nodosFormulaAuxiliar[i]= ""+nodosFormula[i]; 
        } 
         
        try 
        { 
            resultado= Double.parseDouble(evaluar(nodosFormulaAuxiliar, nombreVariable, valorX));
        } 
        catch (NumberFormatException nfe) 
        { 
            System.out.println("Error al convertir string en funcion"   )   ; 
        } 
         
        return resultado; 
    } 
     
     
    public String evaluar(String nodosFormula[], String nombreVariable, double valorVariable)
    { 
        String resultado; 
         
        asignarValorVariable(nodosFormula, nombreVariable, valorVariable); 
         
        resultado= calcularFormula(nodosFormula); 
         
        return resultado; 
    } 
     
    public void asignarValorVariable(String nodosFormula[], String nombreVariable, double valorVariable)
    { 
        for(int i=0;i<nodosFormula.length;i++) 
        { 
            if(nodosFormula[i].equals(nombreVariable)) 
            { 
                nodosFormula[i]= ""+valorVariable; 
                if(i-1>=0) 
                { 
                    if(nodosFormula[i-1].matches("[0-9]*"   )   ) 
                    { 
                        nodosFormula[i]= "*"+valorVariable; 
                    } 
                } 
            } 
        } 
    } 
     
    public String calcularFormula(String nodosFormula[]) 
    { 
        String formula= ""; 
        String resultado= ""; 
         
        for(int i=0;i<nodosFormula.length;i++) 
        { 
            formula= formula+nodosFormula[i]; 
        } 
        //System.out.println("calcularFormula formula "+formula); 
        try 
        { 
            resultado= ""+engine.eval(formula); 
        } 
        catch(ScriptException se) 
        { 
            resultado= "Syntax Error "; 
        } 
         
        return resultado; 
    } 
}

La clase "Romberg" obtiene los valores producidos por la clase "Funcion" y aplica el método de Romberg para obtener una aproximación al valor de la integral definida. 

public class Romberg 
{ 

    public void calculate(Funcion f, double from, double to, int maxIterations) 
    { 
        double[][] r = new double[3][20]; 
        double h = to - from; 
        r[1][1] = (h / 2) * (f.evaluar(from) + f.evaluar(to)); 
        System.out.println(r[1][1]); 
         
        for (int i = 2; i <= maxIterations; i++) 
        { 
            r[2][1] = 0.5 * (r[1][1] + sum(f, from, i, h)); 
            System.out.print(r[2][1] + "  "   )   ; 
            for (int j = 2; j <= i; j++) { 
                r[2][j] = r[2][j - 1] + (r[2][j - 1] - r[1][j - 1]) / (Math.pow(4, j - 1) - 1); 
                System.out.print(r[2][j] + "  "   )   ; 
            } 
            h = h / 2; 
            for (int j = 1; j <= i; j++) 
            { 
                r[1][j] = r[2][j]; 
            } 
            System.out.println(""   )   ; 
        } 
    } 

    private double sum(Funcion f, double a, int n, double h) 
    { 
        double result = 0; 
        for (int i = 1; i <= Math.pow(2, n - 2); i++) 
        { 
            result += f.evaluar(a + (i - 0.5) * h); 
        } 
        return result * h; 
    } 
} 

La clase "Interfaz" se encarga de interactuar con el usuario. El usuario digita la formula y los limites para calcular la integral definida y también digita el numero de iteraciones para el método de Romberg, entre más iteraciones sean, mayor es la aproximación. 

import javax.swing.*; 

import java.awt.*; 
import java.awt.event.*; 
import java.util.Vector; 

import javax.script.ScriptEngine; 
import javax.script.ScriptEngineManager; 

public class Interfaz extends JFrame implements ActionListener 
{ 
JPanel panel1= new JPanel(); 
JPanel panel2= new JPanel(); 

JLabel textoOperacion; 
JTextField campoTextoOperacion; 
String resultado; 
String formula=""; 

Vector nodosDigitados; 

public Interfaz() 
{ 
    setDefaultCloseOperation(this.EXIT_ON_CLOSE); 
     
    Container contenedor = getContentPane(); 
     
    panel1.setLayout(new GridLayout(1,2)); 
     
    textoOperacion= new JLabel( "operacion" ); 
    panel1.add(textoOperacion); 
     
    campoTextoOperacion= new JTextField(10); 
    campoTextoOperacion.setEditable( false ); 
    panel1.add( campoTextoOperacion); 
     
    contenedor.add(panel1,"North" ); 
     
    panel2.setLayout(new FlowLayout()); 
     
    for(int i=0; i<10; i++) 
    { 
        JButton boton= new JButton(""+i); 
        boton.addActionListener(this); 
        panel2.add(boton); 
    } 
     
    JButton botonPI= new JButton("π" ); 
    botonPI.addActionListener(this); 
    botonPI.setActionCommand("Math.PI" ); 
    panel2.add(botonPI); 
     
    JButton botonE= new JButton("e" ); 
    botonE.addActionListener(this); 
    botonE.setActionCommand("Math.E" ); 
    panel2.add(botonE); 
     
    JButton botonParentesis1= new JButton("(" ); 
    botonParentesis1.addActionListener(this); 
    panel2.add(botonParentesis1); 
     
    JButton botonParentesis2= new JButton(";)"   )   ; 
    botonParentesis2.addActionListener(this); 
    panel2.add(botonParentesis2); 
     
    JButton botonPotencia= new JButton("Pow" ); 
    botonPotencia.setActionCommand("Math.pow(" ); 
    botonPotencia.addActionListener(this); 
    panel2.add(botonPotencia); 
     
    JButton botonLogaritmoNatural= new JButton("Log" ); 
    botonLogaritmoNatural.setActionCommand("Math.log(" ); 
    botonLogaritmoNatural.addActionListener(this); 
    panel2.add(botonLogaritmoNatural); 
     
    JButton botonRaizCuadrada= new JButton("√" ); 
    botonRaizCuadrada.setActionCommand("Math.sqrt(" ); 
    botonRaizCuadrada.addActionListener(this); 
    panel2.add(botonRaizCuadrada); 
     
    JButton botonSeno= new JButton("sen" ); 
    botonSeno.setActionCommand("Math.sin(" ); 
    botonSeno.addActionListener(this); 
    panel2.add(botonSeno); 
     
    JButton botonCoseno= new JButton("cos" ); 
    botonCoseno.setActionCommand("Math.cos(" ); 
    botonCoseno.addActionListener(this); 
    panel2.add(botonCoseno); 
     
    JButton botonTangente= new JButton("tan" ); 
    botonTangente.setActionCommand("Math.tan(" ); 
    botonTangente.addActionListener(this); 
    panel2.add(botonTangente); 
     
    JButton botonPunto= new JButton("." ); 
    botonPunto.addActionListener(this); 
    panel2.add(botonPunto); 
     
    JButton botonComa= new JButton("," ); 
    botonComa.addActionListener(this); 
    panel2.add(botonComa); 
     
    JButton botonSumar= new JButton("+" ); 
    botonSumar.addActionListener(this); 
    panel2.add(botonSumar); 
     
    JButton botonRestar= new JButton("-" ); 
    botonRestar.addActionListener(this); 
    panel2.add(botonRestar); 
     
    JButton botonMultiplicar= new JButton("*" ); 
    botonMultiplicar.addActionListener(this); 
    panel2.add(botonMultiplicar); 
     
    JButton botonDividir= new JButton("/" ); 
    botonDividir.addActionListener(this); 
    panel2.add(botonDividir); 
     
    JButton botonX= new JButton("x" ); 
    botonX.addActionListener(this); 
    panel2.add(botonX); 
     
    JButton botonLimpiar= new JButton("Limpiar" ); 
    botonLimpiar.addActionListener(this); 
    panel2.add(botonLimpiar); 
     
    JButton botonFormulaLista= new JButton("Listo" ); 
    botonFormulaLista.addActionListener(this); 
    panel2.add(botonFormulaLista); 
     
    contenedor.add(panel2,"Center" ); 
    nodosDigitados = new Vector(); 
     
    setTitle("Integrar por metodo de Romberg"   )   ; 
    setSize(450, 190); 
    setVisible(true); 
} 


public void actionPerformed(ActionEvent evento) 
{ 
    ScriptEngineManager manager = new ScriptEngineManager(); 
    ScriptEngine engine = manager.getEngineByName("js" ); 
     
    if(!((evento.getActionCommand()).equals("Listo" )||(evento.getActionCommand()).equals("Limpiar" ))) 
    { 
        campoTextoOperacion.setText(campoTextoOperacion.getText()+evento.getActionCommand());
        nodosDigitados.add(evento.getActionCommand()); 
    } 
     
    if((evento.getActionCommand()).equals("Limpiar" )) 
    { 
        setFormula(""   )   ; 
        nodosDigitados= new Vector(); 
    } 
     
    if((evento.getActionCommand()).equals("Listo" )) 
    { 
        calcular(); 
    } 
} 


public void setFormula(String laFormula) 
{ 
    campoTextoOperacion.setText(laFormula); 
} 

public void calcular() 
{ 
    String nodosFormula[]= new String[nodosDigitados.size()]; 
    for(int i=0;i<nodosFormula.length;i++) 
    { 
        nodosFormula[i]= ""+nodosDigitados.get(i); 
    } 
    Funcion f= new Funcion(nodosFormula, "x"   )   ; 
     
    double limiteInferior= Double.parseDouble(JOptionPane.showInputDialog("Digite el limite inferior"   )   )   ;
    double limiteSuperior= Double.parseDouble(JOptionPane.showInputDialog("Digite el limite superior"   )   )   ;
    int iteraciones= Integer.parseInt(JOptionPane.showInputDialog("Digite el numero de iteraciones para ejecutar el meodo de Romberg"   )   )   ;
     
    Romberg romberg= new Romberg(); 
    romberg.calculate(f, limiteInferior, limiteSuperior, iteraciones); 
} 


public static void main(String args[]) 
{ 
new Interfaz(); 
} 
}