SoloCodigo

Hola.

Tengo un archivo en código Java para applet y me gustaría pasarlo a celular, osea que sea ejecutable dentro de un móvil.

Este applet evalua una ecuacion y da el resultado, si gustan pueden probarlo en netbeans, les pego el código:

import java.applet.*;
import java.util.*;
import java.awt.*;
 
public class parser extends java.applet.Applet {
    Parseador miparser=new Parseador(); //Constructor del parseador
    String expresion=new String(); //Expresión a parsear
    double valor=0; //Valor en el que se va a evaluar
    TextField inputexpresion = new TextField("x + 5"); //Textfield donde se digita la expresión a parsear
    TextField inputvalor = new TextField("0",5); //Textfield donde se digita el valor a evaluar en la expresión
    Button boton= new Button("Evaluar la expresión"); //Botón para evaluar
    TextField outputparseo = new TextField("          "); //Resultado de parsear la expresión
    TextField outputevaluar = new TextField("         "); //Resultado de la evaluación en la expresión
    Label info = new Label("Información en extremo importante           ", Label.CENTER); //Label donde se dan los errores
 
    public void init(){ //Todo se pone en el applet
        add(inputexpresion);
        add(inputvalor);
        add(boton);
        add(outputparseo);
        add(outputevaluar);
        add(info);
    }//init
 
    public boolean action(Event evt, Object arg){
        if (evt.target instanceof Button){ //Si se apretó el botón
            try{
                info.setText(""); //Se pone el Label de los errores vacío
                expresion=inputexpresion.getText(); //Se lee la expresión
                valor=Double.valueOf(inputvalor.getText()).doubleValue(); //Se lee el valor a evaluar
                outputparseo.setText(miparser.parsear(expresion)); //Se parsea la expresión
                outputevaluar.setText(""+redondeo(miparser.f(valor),5)); //Se evalúa el valor y se redondea
            }catch(Exception e){ //Si hubo error lo pone en el Label correspondiente
                info.setText(e.toString());
            }
        }//if del botón
        return true;
    }//action
 
    /*
     *Se redondea un número con los decimales dados
     */
    private double redondeo(double numero, int decimales){
        return ((double)Math.round(numero*Math.pow(10,decimales)))/Math.pow(10,decimales);
    }
 
}//PolCero
 
 
/**
 
 *
 *Clase que parsea una expresión matemática.
 *Para parsear se debe crear un objeto (Obj) de tipo Parseador.
 *Para parsear expr se escribe Obj.parsear(Expr).
 *La función devuelve un String con Expr en notación postfija, además
 *el programa también guarda de manera automática la última expresión parseada.
 *Para evaluar el número x en la expresión se utilizar Obj.f(x) para evaluar
 *en la última expresión o se puede pasar una expresión en notación postfija
 *escribiendo Obj.f(exprEnPostfija, x). 
 *
 *La variable permitida es x.
 *La expresión puede contener las constantes pi y e.
 *Los operadores válidos de la expresión son:
 *    OPERACIÓN           OPERADOR
 *  suma                        +
 *  resta                       -
 *  multiplicación              *
 *  división                    /
 *  potencias                   ^
 *  módulo                      %
 *  paréntesis                  ( )
 *  logaritmo (base e)          ln( )
 *  logaritmo (base 10)         log( )
 *  valor absoluto              abs( )
 *  número aleatorio            rnd( )
 *  seno                        sen( )
 *  coseno                      cos( )
 *  tangente                    tan( )
 *  secante                     sec( )
 *  cosecante                   csc( )
 *  cotangente                  cot( )
 *  signo                       sgn( )
 *  arcoseno                    asen( )
 *  arcocoseno                  acos( )
 *  arcotangente                atan( )
 *  arcosecante                 asec( )
 *  arcocosecante               acsc( )
 *  arcocotangente              acot( )
 *  seno hiperbólico            senh( )
 *  coseno hiperbólico          cosh( )
 *  tangente hiperbólica        tanh( )
 *  secante hiperbólica         sech( )
 *  cosecante hiperbólica       csch( )
 *  cotangente hiperbólica      coth( )
 *  raices cuadradas            sqrt( )
 *  arcoseno hiperbólico        asenh( )
 *  arcocoseno hiperbólico      acosh( )
 *  arcotangente hiperbólica    atanh( )
 *  arcosecante hiperbólica     asech( )
 *  arcocosecante hiperbólica   acsch( )
 *  arcocotangente hiperbólica  acoth( )  
 *  redondeo                    round( )
 *
 *Algunos ejemplos de expresiones válidas son:
 *x+cos(3)*tan(x^(2*pi*x-1))/acos(1/2)
 *cosh(x)+abs(1-x^2)%3
 *
 *
 */
 
//Clases importadas
 
 
class Parseador{
 
    //VARIABLES PRIVADAS
   
    //Guarda la última expresión que se tradujo a postfijo para poder evaluar en ella sin dar una nueva expresión
    private String ultimaParseada;
   
   
    //CONSTRUCTORES
   
   
    public Parseador(){
        ultimaParseada="0";
    }
 
 
    //FUNCIONES PUBLICAS
   
   
    /**
     *La función que parsea la expresión a notación postfija.
     *@param expresion El string con la expresión a parsear.
     *@return Un String con la expresión parseada en notación postfija.
     *@exception SintaxException Error de escritura en la expresión.
     */
    public String parsear(String expresion) throws SintaxException{
        Stack PilaNumeros=new Stack(); //Pila donde se guardarán los números al parsear
        Stack PilaOperadores= new Stack(); //Pila donde se guardarán los operadores al parsear
        String expr=quitaEspacios(expresion.toLowerCase());  //La expresión sin espacios ni mayúsculas.
        String fragmento; //Guarda el fragmento de texto que se esté utilizando en el momento (ya sea un número, un operador, una función, etc.)
        int pos=0, tamano=0; //pos marca la posición del caracter que se está procesando actualmente en el String. tamano indica el tamaño del texto que se procesa en ese momento.
        byte cont=1; //contador indica el número de caracteres que se sacan del string en un momento indicado, este no puede ser más de seis (la función con más caracteres tiene seis)
        //Este es un arreglo de Strings que guarda todas las funciones y expresiones permitidas, incluso números, y los acomoda en cada posición de acuerdo a su tamaño
        final String funciones[]={"1 2 3 4 5 6 7 8 9 0 ( ) x e + - * / ^ %",
                            "pi",
                            "ln(",
                            "log( abs( sen( sin( cos( tan( sec( csc( cot( sgn(",
                            "rnd() asen( asin( acos( atan( asec( acsc( acot( senh( sinh( cosh( tanh( sech( csch( coth( sqrt(",
                            "round( asenh( acosh( atanh( asech( acsch( acoth("};
        //Todas las funciones que trabajan como paréntesis de apertura están aquí.
        final String parentesis="( ln log abs sen sin cos tan sec csc cot sgn asen asin acos atan asec acsc acot senh sinh cosh tanh sech csch coth sqrt round asenh asinh acosh atanh asech acsch acoth";
        /*
         *Esta variable 'anterior' se utiliza para saber cuál había sido la última
         *expresión parseada y verificar si hay un error en la expresión o si hay
         *algún menos unario en la expresión, se utiliza:
         *0 : no ha parseado nada
         *1 : un número (número, pi, e, x)
         *2 : un operador binario (+ - * / ^ %)
         *3 : un paréntesis (( sen( cos( etc.)
         *4 : cierre de paréntesis ())
         *Si no se ha parseado nada puede ser cualquier cosa menos (+ * / ^ %)
         *Si el anterior fue un número puede seguir cualquier cosa
         *Si lo anterior fue un operador puede seguir cualquier cosa menos otro operador (con excepción de -)
         *Si lo anterior fue un paréntesis puede seguir cualquier cosa menos (+ * / ^ %)
         *Si lo anterior fue un cierre de paréntesis debe seguir un operador, un número (en cuyo caso hay un por oculto) u otro paréntesis (también hay un por oculto)
         */
        byte anterior=0;
       
        try{
            while(pos<expr.length()){ //Haga mientras la posición sea menor al tamaño del String (mientras este dentro del string)
                tamano=0;
                cont=1;
                while (tamano==0 && cont<=6){ //Este while revisa si el pedazo del texto sacado concuerda con algo conocido
                    if(pos+cont<=expr.length() && funciones[cont-1].indexOf(expr.substring(pos,pos+cont))!=-1){
                        tamano=cont;
                    }
                    cont++;
                }
               
                if (tamano==0){ //Si no encontró nada es por que hubo un error, se pone la ùltima parseada en cero y se lanza una excepción
                    ultimaParseada="0";
                    throw new SintaxException("Error en la expresión");
                }else if(tamano==1){ //Si encontró algo de tamaño uno
                    if(isNum(expr.substring(pos,pos+tamano))){ //Si es un número se encarga de sacarlo completo
                        if(anterior==1 || anterior==4){//si hay una multiplicación oculta
                            sacaOperadores(PilaNumeros, PilaOperadores, "*");
                        }
                        fragmento=""; //aquí se guardará el número sacado
                        do{ //Hágalo mientras lo que siga sea un número o un punto o una coma
                            fragmento=fragmento+expr.charAt(pos);
                            pos++;
                        }while(pos<expr.length() && (isNum(expr.substring(pos,pos+tamano)) || expr.charAt(pos) == '.' || expr.charAt(pos) == ','));
                        try{ //Trate de convertirlo en un número
                            Double.valueOf(fragmento);
                        }catch(NumberFormatException e){ //Si no pudo pasarlo a número hay un error
                            ultimaParseada="0";
                            throw new SintaxException("Número mal digitado");
                        }
                        PilaNumeros.push(new String(fragmento));
                        anterior=1;
                        pos--;
                    }else if (expr.charAt(pos)=='x' || expr.charAt(pos)=='e'){ //Si es un número conocido
                        if(anterior==1 || anterior==4){//si hay una multiplicación oculta
                            sacaOperadores(PilaNumeros, PilaOperadores, "*");
                        }
                        PilaNumeros.push(expr.substring(pos,pos+tamano));
                        anterior=1;
                    }else if (expr.charAt(pos)=='+' || expr.charAt(pos)=='*' || expr.charAt(pos)=='/' || expr.charAt(pos)=='%'){ //Si es suma, multiplicación o división
                        if (anterior==0 || anterior==2 || anterior==3)//Hay error si antes de los operadores no hay nada, hay un paréntesis de apertura o un operador
                            throw new SintaxException("Error en la expresión");
                       
                        sacaOperadores(PilaNumeros, PilaOperadores, expr.substring(pos,pos+tamano));
                        anterior=2;
                    }else if (expr.charAt(pos)=='^'){ //Si es una potencia
                        if (anterior==0 || anterior==2 || anterior==3) //Hay error si antes de un apotencia no hay nada, hay un paréntesis de apertura o un operador
                            throw new SintaxException("Error en la expresión");
                           
                        PilaOperadores.push(new String("^"));
                        anterior=2;
                    }else if (expr.charAt(pos)=='-'){ //Si es una resta
                        if(anterior==0 || anterior==2 || anterior==3){//si hay un menos unario
                            PilaNumeros.push(new String("-1"));
                            sacaOperadores(PilaNumeros, PilaOperadores, "*");
                        }else{//si el menos es binario
                            sacaOperadores(PilaNumeros, PilaOperadores, "-");
                        }
                        anterior=2;
                    }else if (expr.charAt(pos)=='('){
                        if (anterior==1 || anterior == 4){ //si hay una multiplicación oculta
                            sacaOperadores(PilaNumeros, PilaOperadores, "*");
                        }
                        PilaOperadores.push(new String("("));
                        anterior=3;
                    }else if (expr.charAt(pos)==')'){
                        if(anterior!=1 && anterior !=4) //Antes de un cierre de paréntesis sólo puede haber un número u otro cierre de paréntesis, sino hay un error
                            throw new SintaxException("Error en la expresión");
                       
                        while(!PilaOperadores.empty() && parentesis.indexOf(((String)PilaOperadores.peek()))==-1){
                            sacaOperador(PilaNumeros, PilaOperadores);
                        }
                        if(!((String)PilaOperadores.peek()).equals("(")){
                            PilaNumeros.push(new String(((String)PilaNumeros.pop()) + " " + ((String)PilaOperadores.pop())));
                        }else{
                            PilaOperadores.pop();
                        }
                        anterior=4;
                    }
                }else if(tamano>=2){ //Si lo encontrado es de tamaño dos o mayor (todas las funciones se manejan igual)
                    fragmento=expr.substring(pos,pos+tamano);
                    if(fragmento.equals("pi")){ //Si es el número pi
                        if(anterior==1 || anterior==4){//si hay una multiplicación oculta
                            sacaOperadores(PilaNumeros, PilaOperadores, "*");
                        }
                        PilaNumeros.push(fragmento);
                        anterior=1;
                    }else if(fragmento.equals("rnd()")){ //Si es la función que devuelve un número aleatorio (la única función que se maneja como un número)
                        if(anterior==1 || anterior==4){//si hay una multiplicación oculta
                            sacaOperadores(PilaNumeros, PilaOperadores, "*");
                        }
                        PilaNumeros.push("rnd");
                        anterior=1;
                    }else{ //Si es cualquier otra función
                        if (anterior==1 || anterior == 4){ //si hay una multiplicación oculta
                            sacaOperadores(PilaNumeros, PilaOperadores, "*");
                        }
                        PilaOperadores.push(fragmento.substring(0,fragmento.length()-1)); //Se guarda en la pila de funciones sin el paréntesis de apertura (en postfijo no se necesita)
                        anterior=3;
                    }
                }
                pos+=tamano;
            }
       
            //Procesa al final
            while(!PilaOperadores.empty()){ //Saca todos los operadores mientras la pila no esté vacía
                if(parentesis.indexOf((String)PilaOperadores.peek())!=-1)
                    throw new SintaxException("Hay un paréntesis de más");
                sacaOperador(PilaNumeros, PilaOperadores);
            }
       
        }catch(EmptyStackException e){ //Si en algún momento se intenta sacar de la pila y está vacía hay un error
            ultimaParseada="0";
            throw new SintaxException("Expresión mal digitada");
        }
       
        ultimaParseada=((String)PilaNumeros.pop()); //Se obtiene el resultado final
       
        if(!PilaNumeros.empty()){ //Si la pila de números no quedó vacía hay un error
            ultimaParseada="0";
            throw new SintaxException("Error en la expresión");
        }
       
        return ultimaParseada; //Se devuelve el resultado evaluado
    }//Parsear
   
    /**
     *Esta es la función que evalúa una expresión parseada en un valor double.
     *@param expresionParseada Esta es una expresión en notación postfija (se puede obtener con la función parsear).
     *@param x El valor double en el que se evaluará la función.
     *@return El resultado (un valor double) de evaluar x en la expresión.
     *@exception ArithmeticException Error al evaluar en los reales.
     */
    public double f(String expresionParseada, double x) throws ArithmeticException{
        Stack pilaEvaluar = new Stack(); //Pila de doubles para evaluar
        double a, b; //Estos valores son los que se van sacando de la pila de doubles
        StringTokenizer tokens=new StringTokenizer(expresionParseada); //La expresión partida en tokens
        String tokenActual; //El token que se procesa actualmente
       
        try{
            while(tokens.hasMoreTokens()){ //Haga mientras hayan más tokens
                tokenActual=tokens.nextToken();
                /*
                 *La idea aquí es sacar el token que sigue y verificar qué es ese
                 *token y manejarlo de manera:
                 *Si es un número se introduce en la pila de números
                 *Si es una función se sacan el valor o los valores necesarios de la pila
                 *de números y se mete el valor evaluado en la función correspondiente (u
                 *operador correspondiente).
                 */
                if(tokenActual.equals("e")){ //Si es el número e
                    pilaEvaluar.push(new Double(Math.E));
                }else if(tokenActual.equals("pi")){//Si es el número pi
                    pilaEvaluar.push(new Double(Math.PI));
                }else if(tokenActual.equals("x")){//Si es una x se introduce el valor a evaluar por el usuario
                    pilaEvaluar.push(new Double(x));
                }else if(tokenActual.equals("+")){//Si es una suma se sacan dos números y se suman
                    b=((Double)pilaEvaluar.pop()).doubleValue();
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(a+b));
                }else if(tokenActual.equals("-")){//Si es resta se sacan dos valores y se restan (así con todos los operadores)
                    b=((Double)pilaEvaluar.pop()).doubleValue();
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(a-b));
                }else if(tokenActual.equals("*")){//Multiplicación
                    b=((Double)pilaEvaluar.pop()).doubleValue();
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(a*b));
                }else if(tokenActual.equals("/")){//División
                    b=((Double)pilaEvaluar.pop()).doubleValue();
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(a/b));
                }else if(tokenActual.equals("^")){//Potencia
                    b=((Double)pilaEvaluar.pop()).doubleValue();
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.pow(a,b)));
                }else if(tokenActual.equals("%")){//Resto de la división entera
                    b=((Double)pilaEvaluar.pop()).doubleValue();
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(a%b));
                }else if(tokenActual.equals("ln")){//Si es logaritmo natural sólo se saca un valor de la pila y se evalúa
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.log(a)));
                }else if(tokenActual.equals("log")){//Logaritmo en base 10
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.log(a)/Math.log(10)));
                }else if(tokenActual.equals("abs")){//Valor absoluto
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.abs(a)));
                }else if(tokenActual.equals("rnd")){//Un número a random simplemente se mete en la pila de números
                    pilaEvaluar.push(new Double(Math.random()));
                }else if(tokenActual.equals("sen") || tokenActual.equals("sin")){ //Seno
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.sin(a)));
                }else if(tokenActual.equals("cos")){//Coseno
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.cos(a)));
                }else if(tokenActual.equals("tan")){//Tangente
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.tan(a)));
                }else if(tokenActual.equals("sec")){//Secante
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(1/Math.cos(a)));
                }else if(tokenActual.equals("csc")){//Cosecante
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(1/Math.sin(a)));
                }else if(tokenActual.equals("cot")){//Cotangente
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(1/Math.tan(a)));
                }else if(tokenActual.equals("sgn")){//Signo
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(sgn(a)));
                }else if(tokenActual.equals("asen") || tokenActual.equals("asin")){ //Arcoseno
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.asin(a)));
                }else if(tokenActual.equals("acos")){//Arcocoseno
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.acos(a)));
                }else if(tokenActual.equals("atan")){//Arcotangente
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.atan(a)));
                }else if(tokenActual.equals("asec")){//Arcosecante
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.acos(1/a)));
                }else if(tokenActual.equals("acsc")){//Arcocosecante
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.asin(1/a)));
                }else if(tokenActual.equals("acot")){//Arcocotangente
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.atan(1/a)));
                }else if(tokenActual.equals("senh") || tokenActual.equals("sinh")){//Seno hiperbólico
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double((Math.exp(a)-Math.exp(-a))/2));
                }else if(tokenActual.equals("cosh")){//Coseno hiperbólico
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double((Math.exp(a)+Math.exp(-a))/2));
                }else if(tokenActual.equals("tanh")){//tangente hiperbólica
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double((Math.exp(a)-Math.exp(-a))/(Math.exp(a)+Math.exp(-a))));
                }else if(tokenActual.equals("sech")){//Secante hiperbólica
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(2/(Math.exp(a)+Math.exp(-a))));
                }else if(tokenActual.equals("csch")){//Cosecante hiperbólica
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(2/(Math.exp(a)-Math.exp(-a))));
                }else if(tokenActual.equals("coth")){//Cotangente hiperbólica
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double((Math.exp(a)+Math.exp(-a))/(Math.exp(a)-Math.exp(-a))));
                }else if(tokenActual.equals("asenh") || tokenActual.equals("asinh")){ //Arcoseno hiperbólico
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.log(a+Math.sqrt(a*a+1))));
                }else if(tokenActual.equals("acosh")){//Arcocoseno hiperbólico
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.log(a+Math.sqrt(a*a-1))));
                }else if(tokenActual.equals("atanh")){//Arcotangente hiperbólica
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.log((1+a)/(1-a))/2));
                }else if(tokenActual.equals("asech")){//Arcosecante hiperbólica
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.log((Math.sqrt(1-a*a)+1)/a)));
                }else if(tokenActual.equals("acsch")){//Arcocosecante hiperbólica
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.log((sgn(a)*Math.sqrt(a*a +1)+1)/a)));
                }else if(tokenActual.equals("acoth")){//Arcocotangente hiperbólica
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.log((a+1)/(a-1))/2));
                }else if(tokenActual.equals("sqrt")){//Raíz cuadrada
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Math.sqrt(a)));
                }else if(tokenActual.equals("round")){//Redondear
                    a=((Double)pilaEvaluar.pop()).doubleValue();
                    pilaEvaluar.push(new Double(Long.toString(Math.round(a))));
                }else{//si es otra cosa tiene que ser un número, simplemente se mete en la pila
                    pilaEvaluar.push(Double.valueOf(tokenActual));
                }
            }//while
        }catch(EmptyStackException e){ //Si en algún momento se acabó la pila hay un error
            throw new ArithmeticException("Expresión mal parseada");
        }catch(NumberFormatException e){ //Si hubo error al traducir un número hay un error
            throw new ArithmeticException("Expresión mal digitada");
        }catch(ArithmeticException e){ //Cualquier otro error de división por cero o logaritmo negativo, etc.
            throw new ArithmeticException("Valor no real en la expresión");
        }
       
        a=((Double)pilaEvaluar.pop()).doubleValue(); //El valor a devolver
       
        if(!pilaEvaluar.empty()) //Si todavía quedó otro valor en la pila hay un error
            throw new ArithmeticException("Expresión mal digitada");
           
        return a;
    }//funcion f
   
    /**
     *Esta función evalua la última expresión parseada en el valor x.
     *@param x valor a evaluar.
     *@return la evaluación del polinomio en el valor x.
     */
    public double f(double x) throws ArithmeticException{
        try{
            return f(ultimaParseada,x);
        }catch(ArithmeticException e){
            throw e;
        }
    }//Fin de la funcion f
   
   
   
    //FUNCIONES PRIVADAS
   
   
    /*
     *sacaOperador es una función que se encarga de sacar un operador de la pila
     *y manejarlo de manera apropiada, ya sea un operador unario o binario
     */
    private void sacaOperador(Stack Numeros, Stack operadores) throws EmptyStackException{
        String operador, a, b;
        final String operadoresBinarios="+ - * / ^ %"; //Lista de los operadores binarios
       
        try{
            operador=(String)operadores.pop(); //Saca el operador que se debe evaluar
           
            if(operadoresBinarios.indexOf(operador)!=-1){ //Si es un operador binario saca dos elementos de la pila y guarda la operación
                b=(String)Numeros.pop();
                a=(String)Numeros.pop();
                Numeros.push(new String(a+" "+b+" "+operador));
            }else{ //Sino sólo saca un elemento
                a=(String)Numeros.pop();
                Numeros.push(new String(a+" "+operador));
            }
        }catch(EmptyStackException e){
            throw e;
        }
    }//sacaOperador
   
    /*
     *sacaOperadores saca los operadores que tienen mayor prioridad y mete el nuevo operador
     */
    private void sacaOperadores(Stack PilaNumeros, Stack PilaOperadores, String operador){
        //Todas las funciones que se manejan como paréntesis de apertura
        final String parentesis="( ln log abs sen sin cos tan sec csc cot sgn asen asin acos atan asec acsc acot senh sinh cosh tanh sech csch coth sqrt round asenh asinh acosh atanh asech acsch acoth";
       
        //mientras la pila no esté vacía, el operador que sigue no sea un paréntesis de apertura, la longitud del operador sea uno (para que sea un operador), y la prioridad indique que tiene que seguir sacando elementos
        while(!PilaOperadores.empty() && parentesis.indexOf((String)PilaOperadores.peek())==-1 && ((String)PilaOperadores.peek()).length()==1 && prioridad(((String)PilaOperadores.peek()).charAt(0))>=prioridad(operador.charAt(0))){
            sacaOperador(PilaNumeros, PilaOperadores); //Saca el siguiente operador
        }
        PilaOperadores.push(operador);//Al final mete el nuevo operador luego de sacar todo lo que tenía que sacar.
    }
   
    /*
     *Función que devuelve la prioridad de una operacion
     */
    private int prioridad(char s) {
        if (s=='+' || s=='-') //Si es una suma o una resta devuelve cero
            return 0;
        else if (s=='*' || s=='/' || s=='%') //Si es multiplicación, división o resto de división devuelve uno
            return 1;
        else if (s=='^')//Si es potencia devuelve dos
            return 2;
           
        return -1; //Si no fue nada de lo anterior devuelve -1
    } //Fin de la funcion prioridad
 
    /*
     *Función que pregunta si un caracter es un número o no
     */
    private boolean isNum(String s) {
        if (s.compareTo("0")>=0 && s.compareTo("9")<=0) //Si el caracter está entre 0 y 9 (si es un número)
            return true;
        else
            return false;
    } //Fin de la funcion isNum
   
    /*
     *Quita los espacios del String con el polinomio
     */ 
    private String quitaEspacios(String polinomio){
        String unspacedString = ""; //Variable donde lee la función
 
        for(int i = 0; i < polinomio.length(); i++){    //Le quita los espacios a la espresión que leyó
            if(polinomio.charAt(i) != ' ') //Si el caracter no es un espacio lo pone, sino lo quita.
                unspacedString += polinomio.charAt(i);
        }//for
       
        return unspacedString;
    }//quitaEspacios
   
    /*
     *Devuelve el signo del número dado
     */
    private double sgn(double a){
        if(a<0) //Si el número es negativo devuelve -1
            return -1;
        else if(a>0)//Si es positivo devuelve 1
            return 1;
        else//Si no es negativo ni positivo devuelve cero
            return 0;
    }
   
 
    //CLASES PRIVADAS
 
 
    //Clase SintaxException
   
    //Esta es la excepción que se lanza si hay algún error sintáctico en la expresión
    private class SintaxException extends ArithmeticException{ //En realidad extiende la ArithmeticException
        public SintaxException(){ //Si se llama con el mensaje por defecto
            super("Error de sintaxis en el polinomio"); //El constructor llama a la clase superior
        }
       
        public SintaxException(String e){ //si se llama con otro mensaje
            super(e); //El constructor llama a la clase superior
        }
    }
}//fin de Parseador


Me gustaría que me ayudaran a pasarlo para que sea ejecutable en un celular o móvil, ¿qué debo de cambiar? o ¿qué debo realizar?

De antemano les estoy agradecido.

Saludos.

Hola.

Tengo un ciclo 'for' en mi página que toma valores de mi BD e imprime categorías y subcategorías, lo más seguro es que no me explique, así que pondé un ejemplo de mi BD y un ejemplo de como quiero que aparezca en la página.

Así está más o menos mi BD:

[php:2bvfd1db][/php:2bvfd1db]

Y en la página como les repito, es un ciclo for, me gustaría hacer un 'SELECT' de alguna manera para que en la página ya apareciera algo así:

América -> México -> D.F.
Europa ->  Inglaterra -> Liverpool
etc.

Así como en la base de datos, pero por orden, yo intenté pero sólo me toma un valor no todos, sino me explico díganme y seré más detallado.

Digamos que primero se hace una consulta para ver el total de lineas que se van a tomar en cuenta con ésto:

[php:2bvfd1db][/php:2bvfd1db]

Y luego el ciclo 'for':
[php:2bvfd1db][/php:2bvfd1db]

Me faltó agregar al ejemplo de mi BD que lleva una llave, para separar, aunque en el ejemplo que les mostré arriba todos llevan la misma llave, así que no importa.

Espero puedan ayudarme, se los agradezco de antemano.

Saludos.

Hola.

Me gustaría que alguien pudiera decirme como mandar variables entre páginas en javascript, y por ende también como recibirlas en la otra página.

También tenía otra dudilla, esa variable de javascript ¿cómo podría pasarla a php para trabajar con ella ¿hay alguna manera de hacer esto?

De antemano, muchas gracias.

Hola.

Tengo una página en la cual estoy haciendo un proceso de insertar valores en una BD, ésta página está completamente en blanco, como dije sólo la cree para insertar los valores de páginas anteriores, pero el problema es que tiene 2 frames de cabecera y menú, lo que yo quiero es que al momento de insertar los valores, se redireccione a la primera página, pero que también se carguen los 2 frames antes mencionados.

¿Cómo podría hacer esto?

Gracias de antemano por su ayuda, un saludo.

Problema resuelto, gracias.

Hola, es mi primer post en éste foro, y espero poder aportar mucho a él, así como recibir aportes también, ojalá puedan ayudarme con éste problemita que tengo.

Tengo un código que toma valores de un archivo CSV (Excel) que está de ésta forma:





Lo que quiero es que suba estos valores y los acomode en una tabla, eso no es el problema, el problema es que, por ejemplo en clave tengo "J" en la primera fila, tengo que relacionar esa letra con otros valores que tengo en OTRA tabla en la BD, el valor sería algo como "J12345", pero hay más valores, supongamos que en la tabla ésa tengo los valores así:




Ahora si en la primera fila del archivo CSV que estoy subiendo, la clave es "J", sólo debe de tomar en cuenta los que empiecen con la letra "J" y tomar el que sea más grande, en este caso sería "J2485", entonces quiero que ese valor se le sume uno y lo inserte en la tabla principal donde voy a subir todo, así igual con si cambia de "J" a "B" o viceversa y me quede algo así:





Aquí está el pedazo del código que hace eso, está CASI completo, pero me marca algunos errores:



Y me marca éstos errores:



Ésta es la línea 42:

Espero puedan ayudarme, por más que le busco al código no le encuentro el problema, gracias de antemano.

Saludos.