计算器基础原理代码(java)

 

import java.util.regex.*;
import java.util.*;
import java.text.*;

public class JEvaluator {
  private String expression ;
  private Map variables;
  private Stack tokens;

  /**
   * @param expression
   */
  public JEvaluator(String expression){
    this.expression = expression.toUpperCase();
    variables=new HashMap();
  }

  public static void main(String[] args)
  {
    JEvaluator r = new JEvaluator("x<=10/z and y=8*z and name<>'CESAR' or birth_date    try{      
      r.setVariable("x",5);
      r.setVariable("y",50);
      r.setVariable("z",8);
      r.setVariable("name","CESAR");
      r.setVariable("birth_date",new Date());
      
      //r.printStack();
      System.out.println("result = " + r.eval());
      r.setExpression("10+3*2^x-10*sin(1-x/y)");
      r.setVariable("x",5.36);
      r.setVariable("y",47);
      System.out.println("result = " + r.eval());

      r.setExpression("10+sin(3^(1/2))");
      System.out.println("result = " + r.eval());
  
    }catch(Exception ex){
      ex.printStackTrace();
      r.printStack();
    }
  }

  /**
   * @param s, the expression to be evaluated
   */
  public void setExpression(String s){
    this.expression = s.toUpperCase(); //case insensitive.
    this.tokens=null;
    this.variables=new HashMap();
  }

  /**
   * @return the current expression
   */
  public String getExpression(){
    return this.expression;
  }

  /**
   * @return String[] array of current variable names
   */
  public String[] getVariables(){
    String[] vars=new String[variables.size()];
    variables.keySet().toArray(vars);
    return vars;
  }

  /**
   * Sets the value of the variables present in the expression.
   * @param var, variable name (case insentive)
   * @param val, value
   */
  public void setVariable(String var, Object val){
    //if(!variables.containsKey(var)) throw Exception("No existe variable " + var);
    variables.put(var.toUpperCase(),val);
  }

  /**
   * Evaluates the current expression, and returns the result Object: double or boolean
   * @return result (double for mathematical expression, and boolean for logical expression)
   * @throws Exception
   */
  public Object eval()throws Exception{
    if(tokens==null) init();
  
    Stack operand=new Stack();
    Token t1=null;
    Token t2 =null;
    Object result = null;
  
    for(Token t: tokens){
      if(t.type!=Token.Type.OPERATOR){
        operand.push(t);
      }else{
        Operator ope = (Operator)t.value();
        t1 = operand.pop();        
  
        if(ope.isUnary()){
          result = ope.eval(evalToken(t1));
        }else{
          t2 = operand.pop();
          result = ope.eval( evalToken(t2),evalToken(t1));
        }
        //System.out.println("Operacion :" + t + " with :" + t2 + " , " + t1 + " =" + result);
        if(result==null)throw new Exception("Null result on intermediate operation.["+ ope + ":" + t1 + ", " + t2+ "]");
  
        operand.push(new Token(result,Token.Type.CONSTANT));
      }
    }
    return operand.pop().value(); //voila the magic result
  }

  private Object evalToken(Token t)throws Exception{
    switch(t.type){
      case VARIABLE:
        Object var = variables.get(t.value());//retrieve variable value
        if(var==null) throw new Exception("Variable '"+t.value() + "' value not set.");
        return var;
      case CONSTANT:
        return t.value();
      default:
        throw new Exception("Unexpected token type ." + t.type);
    }
  }

  private void init()throws Exception{
    if(expression==null) throw new Exception("Not expression set.");
    //creating operators pattern.  you may add other operator patterns too. but take care of not conflicting with others.  
    Pattern p = Pattern.compile("//s*(<=|>=|<>|=|>|<|//*|/|//+|-|//^|//(|//))//s*|//s+(AND|OR)//s+|(SIN|COS)");
    Matcher matcher = p.matcher(expression);
    //initializing variables
    int start = 0;
    int len = expression.length();

    tokens=new Stack();
    Stack temp=new Stack();
    Token token = null;

    //parsing tokens and converting infix expression to postfix stack
    while(matcher.find()){
      String ope = matcher.group();
      //System.out.println("match:" + ope);
      //avoid matching an operator as part of a variable e.g. sintesis
      if(ope.matches("//w+") && (
        matcher.start()>0 && (expression.charAt(matcher.start()-1)+ope).matches("//w+")
        || matcher.end()        continue;
      }
      //parse operand token
      if(matcher.start()>start){
        token =parseToken(expression.substring(start,matcher.start()));      
        addToken(temp, token);        
        //System.out.println("Token:" + token);
      }
      //parse operator token
      token = new Token(Operator.parse(ope.trim()));
      //System.out.println("Token:" + token);
      addToken(temp, token);
      start=matcher.end();
    }
    //parse last operand token
    if(start      token =parseToken(expression.substring(start,len));      
      addToken(temp, token);
    }
    //ending tokens stack builder
    while(!temp.empty()){
      Token t = temp.pop();
      if(t.inputPriority()==t.stackPriority()) //exclude brackets
        tokens.push(t);
    }
  }

  protected Token parseToken(String val)throws Exception{
      //analize token: constant?, variable?
      Token.Type type = null;
      Object obj=null;
  
      if(val.matches("'[^']*'")){//string constant
        type=Token.Type.CONSTANT;
        obj=val.substring(1,val.length()-1);
      }else if(val.matches("DATE//'//d{2,2}//,//d{2,2}//,//d{4,4}//'")){//date constant
        type=Token.Type.CONSTANT;
        SimpleDateFormat sdf = new SimpleDateFormat("dd,MM,yyyy");
        obj=sdf.parse(val.substring(6,val.length()-1));
      }else if(val.matches("//d*//.?//d*")){//numeric
        type=Token.Type.CONSTANT;
        obj= Double.parseDouble(val);
      }else if(val.matches("//w+")){//variable
        if(!variables.containsKey(val))variables.put(val,null);
        type=Token.Type.VARIABLE;
        obj=val;
      }else{
        throw new Exception("token not recognized: " + val);
      }
      return new Token(obj,type);
  }

  private void addToken(Stack temp, Token t){
    //applying infix to postfix conversion algorithm
    while(!temp.empty() && t.inputPriority()<=temp.peek().stackPriority()){
      Token t1=temp.pop();
      if(t1.inputPriority()==t1.stackPriority()){ //exclude brackets
        tokens.push(t1);
      }        
    }
    //pushing the token
    temp.push(t);
  }

  /**
   * prints to standard output the tokens stack.
   */
  public void printStack(){
    for(Token t: tokens){
      System.out.println(t);
    }
  }
}

/**
* Represents a token of the expression
*/
class Token
{
  public enum Type{VARIABLE,CONSTANT,OPERATOR};  
  private Object value;
  public Type type;
  
  /**
   * @param val
   * @param type
   */
  public Token(Object val, Type type){
    this.value=val;
    this.type=type;
  }
  /**
   * @param ope
   */
  public Token(Operator ope){
    this.value=ope;
    this.type=Type.OPERATOR;
  }

  /**
   * @return
   */
  int inputPriority(){
    if(type==Type.OPERATOR) return ((Operator)value).inputPriority();
    else return Operator.LAST_PRIORITY;
  }

  /**
   * @return
   */
  int stackPriority(){
    if(type==Type.OPERATOR) return ((Operator)value).stackPriority();
    else return Operator.LAST_PRIORITY;
  }

  /**
   * @return
   */
  public Object value(){
    return this.value;
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  public String toString(){
    return type + ":" + value;
  }

};

//operator types: * / + - = < > <= >= & |
/**
* Represents each operation implemented for the evaluator.
*/
enum Operator{
  SIN("SIN",25,true){Object eval(Object... args){return Math.sin(((Number)args[0]).doubleValue());} },
  COS("COS",25,true){Object eval(Object... args){return Math.cos(((Number)args[0]).doubleValue());} },
  TAN("TAN",25,true){Object eval(Object... args){return Math.tan(((Number)args[0]).doubleValue());} },
  EXP("^",23){Object eval(Object... args){return Math.pow(((Number)args[0]).doubleValue(),((Number)args[1]).doubleValue());} },
  PROD("*",20){Object eval(Object... args){return ((Number)args[0]).doubleValue()*((Number)args[1]).doubleValue();} },
  DIV("/",20){Object eval(Object... args){return ((Number)args[0]).doubleValue()/((Number)args[1]).doubleValue();} },
  SUM("+",15){Object eval(Object... args){return ((Number)args[0]).doubleValue()+((Number)args[1]).doubleValue();} },
  DIF("-",15){Object eval(Object... args){return ((Number)args[0]).doubleValue()-((Number)args[1]).doubleValue();} },
  EQL("=",10){Object eval(Object... args){return args[0].equals(args[1]);} },
  NEQL("<>",10){Object eval(Object... args){return !args[0].equals(args[1]);} },
  LT("<",10){Object eval(Object... args){
    if(args[0] instanceof Number) return ((Number)args[0]).doubleValue()<((Number)args[1]).doubleValue();
    else return ((Comparable)args[0]).compareTo(args[1])<0;} },
  GT(">",10){Object eval(Object... args){
    if(args[0] instanceof Number) return ((Number)args[0]).doubleValue()>((Number)args[1]).doubleValue();
    else return ((Comparable)args[0]).compareTo(args[1])>0;} },
  LTEQ("<=",10){Object eval(Object... args){
    if(args[0] instanceof Number) return ((Number)args[0]).doubleValue()<=((Number)args[1]).doubleValue();
    else return ((Comparable)args[0]).compareTo(args[1])<=0;} },
  GTEQ(">=",10){Object eval(Object... args){
    if(args[0] instanceof Number) return ((Number)args[0]).doubleValue()>=((Number)args[1]).doubleValue();
    else return ((Comparable)args[0]).compareTo(args[1])>=0;} },
  AND("AND",5){Object eval(Object... args){return (Boolean)args[0] && (Boolean)args[1];}},
  OR("OR",2){Object eval(Object... args){return ((Boolean)args[0] || (Boolean)args[1]);}},
  BRAKET_OPEN("(",30,1){Object eval(Object... args){return null;}},
   BRAKET_CLOSE(")",1,30){Object eval(Object... args){return null;}};

  public static final int LAST_PRIORITY=30;    
  private final int inputPriority;//prioridad
  private final int stackPriority;
  private final String symbol;
  private boolean unary=false;

  /**
   * @return the operator input priority
   */
  int inputPriority(){return inputPriority;}
  int stackPriority(){return stackPriority;}
  String symbol(){return symbol;}
  boolean isUnary(){return unary;}

  private Operator(String symbol,int prio){
    this.inputPriority=prio;
    this.stackPriority=prio;
    this.symbol=symbol;
  }
  private Operator(String symbol,int prio, boolean unary){
    this.inputPriority=prio;
    this.stackPriority=prio;
    this.symbol=symbol;
    this.unary=unary;
  }
  private Operator(String symbol,int inprio, int stackprio){
    this.inputPriority=inprio;
    this.stackPriority=stackprio;
    this.symbol=symbol;
  }

  abstract Object eval(Object... args);

  public static Operator parse(String s)throws Exception{
    for(Operator o:Operator.values()){
      if(o.symbol().equals(s)){
        return o;
      }
    }
    throw new Exception("Operator not recognized '"+s+"'");
  }
};