328 lines
10 KiB
Java
328 lines
10 KiB
Java
package org.nfunk.jep;
|
|
|
|
import java.io.StringReader;
|
|
import java.util.Vector;
|
|
import org.nfunk.jep.function.Abs;
|
|
import org.nfunk.jep.function.ArcCosine;
|
|
import org.nfunk.jep.function.ArcCosineH;
|
|
import org.nfunk.jep.function.ArcSine;
|
|
import org.nfunk.jep.function.ArcSineH;
|
|
import org.nfunk.jep.function.ArcTanH;
|
|
import org.nfunk.jep.function.ArcTangent;
|
|
import org.nfunk.jep.function.ArcTangent2;
|
|
import org.nfunk.jep.function.Arg;
|
|
import org.nfunk.jep.function.ComplexPFMC;
|
|
import org.nfunk.jep.function.Cosine;
|
|
import org.nfunk.jep.function.CosineH;
|
|
import org.nfunk.jep.function.Exp;
|
|
import org.nfunk.jep.function.If;
|
|
import org.nfunk.jep.function.Imaginary;
|
|
import org.nfunk.jep.function.Logarithm;
|
|
import org.nfunk.jep.function.Modulus;
|
|
import org.nfunk.jep.function.NaturalLogarithm;
|
|
import org.nfunk.jep.function.Polar;
|
|
import org.nfunk.jep.function.PostfixMathCommandI;
|
|
import org.nfunk.jep.function.Random;
|
|
import org.nfunk.jep.function.Real;
|
|
import org.nfunk.jep.function.Sine;
|
|
import org.nfunk.jep.function.SineH;
|
|
import org.nfunk.jep.function.SquareRoot;
|
|
import org.nfunk.jep.function.Str;
|
|
import org.nfunk.jep.function.Sum;
|
|
import org.nfunk.jep.function.TanH;
|
|
import org.nfunk.jep.function.Tangent;
|
|
import org.nfunk.jep.type.Complex;
|
|
import org.nfunk.jep.type.DoubleNumberFactory;
|
|
import org.nfunk.jep.type.NumberFactory;
|
|
|
|
public class JEP {
|
|
private static final boolean debug = false;
|
|
|
|
private boolean traverse = false;
|
|
|
|
protected boolean allowUndeclared = false;
|
|
|
|
protected boolean allowAssignment;
|
|
|
|
protected boolean implicitMul;
|
|
|
|
protected SymbolTable symTab;
|
|
|
|
protected FunctionTable funTab;
|
|
|
|
protected Vector errorList;
|
|
|
|
protected Parser parser;
|
|
|
|
private Node topNode = null;
|
|
|
|
protected EvaluatorVisitor ev;
|
|
|
|
protected NumberFactory numberFactory;
|
|
|
|
protected OperatorSet opSet;
|
|
|
|
public JEP() {
|
|
this.allowAssignment = false;
|
|
this.implicitMul = false;
|
|
this.numberFactory = (NumberFactory)new DoubleNumberFactory();
|
|
this.opSet = new OperatorSet();
|
|
initSymTab();
|
|
initFunTab();
|
|
this.errorList = new Vector();
|
|
this.ev = new EvaluatorVisitor();
|
|
this.parser = new Parser(new StringReader(""));
|
|
}
|
|
|
|
public JEP(boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3, NumberFactory paramNumberFactory) {
|
|
this.implicitMul = paramBoolean3;
|
|
if (paramNumberFactory == null) {
|
|
this.numberFactory = (NumberFactory)new DoubleNumberFactory();
|
|
} else {
|
|
this.numberFactory = paramNumberFactory;
|
|
}
|
|
initSymTab();
|
|
initFunTab();
|
|
this.errorList = new Vector();
|
|
this.ev = new EvaluatorVisitor();
|
|
this.parser = new Parser(new StringReader(""));
|
|
parseExpression("");
|
|
}
|
|
|
|
protected JEP(JEP paramJEP) {
|
|
this.allowAssignment = paramJEP.allowAssignment;
|
|
this.implicitMul = paramJEP.implicitMul;
|
|
this.ev = paramJEP.ev;
|
|
this.funTab = paramJEP.funTab;
|
|
this.numberFactory = paramJEP.numberFactory;
|
|
this.parser = paramJEP.parser;
|
|
this.symTab = paramJEP.symTab;
|
|
this.errorList = paramJEP.errorList;
|
|
}
|
|
|
|
public void initSymTab() {
|
|
this.symTab = new SymbolTable(new VariableFactory());
|
|
}
|
|
|
|
public void initFunTab() {
|
|
this.funTab = new FunctionTable();
|
|
}
|
|
|
|
public void addStandardFunctions() {
|
|
this.funTab.put("sin", (PostfixMathCommandI)new Sine());
|
|
this.funTab.put("cos", (PostfixMathCommandI)new Cosine());
|
|
this.funTab.put("tan", (PostfixMathCommandI)new Tangent());
|
|
this.funTab.put("asin", (PostfixMathCommandI)new ArcSine());
|
|
this.funTab.put("acos", (PostfixMathCommandI)new ArcCosine());
|
|
this.funTab.put("atan", (PostfixMathCommandI)new ArcTangent());
|
|
this.funTab.put("atan2", (PostfixMathCommandI)new ArcTangent2());
|
|
this.funTab.put("sinh", (PostfixMathCommandI)new SineH());
|
|
this.funTab.put("cosh", (PostfixMathCommandI)new CosineH());
|
|
this.funTab.put("tanh", (PostfixMathCommandI)new TanH());
|
|
this.funTab.put("asinh", (PostfixMathCommandI)new ArcSineH());
|
|
this.funTab.put("acosh", (PostfixMathCommandI)new ArcCosineH());
|
|
this.funTab.put("atanh", (PostfixMathCommandI)new ArcTanH());
|
|
this.funTab.put("log", (PostfixMathCommandI)new Logarithm());
|
|
this.funTab.put("ln", (PostfixMathCommandI)new NaturalLogarithm());
|
|
this.funTab.put("exp", (PostfixMathCommandI)new Exp());
|
|
this.funTab.put("sqrt", (PostfixMathCommandI)new SquareRoot());
|
|
this.funTab.put("abs", (PostfixMathCommandI)new Abs());
|
|
this.funTab.put("mod", (PostfixMathCommandI)new Modulus());
|
|
this.funTab.put("sum", (PostfixMathCommandI)new Sum());
|
|
this.funTab.put("rand", (PostfixMathCommandI)new Random());
|
|
this.funTab.put("if", (PostfixMathCommandI)new If());
|
|
this.funTab.put("str", (PostfixMathCommandI)new Str());
|
|
}
|
|
|
|
public void addStandardConstants() {
|
|
this.symTab.addConstant("pi", new Double(Math.PI));
|
|
this.symTab.addConstant("e", new Double(Math.E));
|
|
}
|
|
|
|
public void addComplex() {
|
|
this.symTab.addConstant("i", new Complex(0.0D, 1.0D));
|
|
this.funTab.put("re", (PostfixMathCommandI)new Real());
|
|
this.funTab.put("im", (PostfixMathCommandI)new Imaginary());
|
|
this.funTab.put("arg", (PostfixMathCommandI)new Arg());
|
|
this.funTab.put("cmod", (PostfixMathCommandI)new Abs());
|
|
this.funTab.put("complex", (PostfixMathCommandI)new ComplexPFMC());
|
|
this.funTab.put("polar", (PostfixMathCommandI)new Polar());
|
|
}
|
|
|
|
public void addFunction(String paramString, PostfixMathCommandI paramPostfixMathCommandI) {
|
|
this.funTab.put(paramString, paramPostfixMathCommandI);
|
|
}
|
|
|
|
public Double addVariable(String paramString, double paramDouble) {
|
|
Double double_ = new Double(paramDouble);
|
|
this.symTab.makeVarIfNeeded(paramString, double_);
|
|
return double_;
|
|
}
|
|
|
|
public void addConstant(String paramString, Object paramObject) {
|
|
this.symTab.addConstant(paramString, paramObject);
|
|
}
|
|
|
|
public Complex addVariable(String paramString, double paramDouble1, double paramDouble2) {
|
|
Complex complex = new Complex(paramDouble1, paramDouble2);
|
|
this.symTab.makeVarIfNeeded(paramString, complex);
|
|
return complex;
|
|
}
|
|
|
|
public void addVariable(String paramString, Object paramObject) {
|
|
this.symTab.makeVarIfNeeded(paramString, paramObject);
|
|
}
|
|
|
|
public Object removeVariable(String paramString) {
|
|
return this.symTab.remove(paramString);
|
|
}
|
|
|
|
public Object getVarValue(String paramString) {
|
|
return this.symTab.getVar(paramString).getValue();
|
|
}
|
|
|
|
public boolean setVarValue(String paramString, Object paramObject) {
|
|
return this.symTab.setVarValue(paramString, paramObject);
|
|
}
|
|
|
|
public Variable getVar(String paramString) {
|
|
return this.symTab.getVar(paramString);
|
|
}
|
|
|
|
public Object removeFunction(String paramString) {
|
|
return this.funTab.remove(paramString);
|
|
}
|
|
|
|
public void setTraverse(boolean paramBoolean) {
|
|
this.traverse = paramBoolean;
|
|
}
|
|
|
|
public boolean getTraverse() {
|
|
return this.traverse;
|
|
}
|
|
|
|
public void setImplicitMul(boolean paramBoolean) {
|
|
this.implicitMul = paramBoolean;
|
|
}
|
|
|
|
public boolean getImplicitMul() {
|
|
return this.implicitMul;
|
|
}
|
|
|
|
public void setAllowUndeclared(boolean paramBoolean) {
|
|
this.allowUndeclared = paramBoolean;
|
|
}
|
|
|
|
public boolean getAllowUndeclared() {
|
|
return this.allowUndeclared;
|
|
}
|
|
|
|
public void setAllowAssignment(boolean paramBoolean) {
|
|
this.allowAssignment = paramBoolean;
|
|
}
|
|
|
|
public boolean getAllowAssignment() {
|
|
return this.allowAssignment;
|
|
}
|
|
|
|
public void parseExpression(String paramString) {
|
|
StringReader stringReader = new StringReader(paramString);
|
|
try {
|
|
this.errorList.removeAllElements();
|
|
this.topNode = this.parser.parseStream(stringReader, this);
|
|
} catch (Throwable throwable) {
|
|
this.topNode = null;
|
|
if (throwable instanceof ParseException) {
|
|
this.errorList.addElement(((ParseException)throwable).getMessage());
|
|
} else {
|
|
this.errorList.addElement("Syntax error");
|
|
}
|
|
}
|
|
if (this.traverse && !hasError()) {
|
|
ParserDumpVisitor parserDumpVisitor = new ParserDumpVisitor();
|
|
try {
|
|
this.topNode.jjtAccept(parserDumpVisitor, null);
|
|
} catch (ParseException parseException) {
|
|
this.errorList.addElement(parseException.getMessage());
|
|
}
|
|
}
|
|
}
|
|
|
|
public Node parse(String paramString) throws ParseException {
|
|
StringReader stringReader = new StringReader(paramString);
|
|
return this.parser.parseStream(stringReader, this);
|
|
}
|
|
|
|
public Object evaluate(Node paramNode) throws Exception {
|
|
return this.ev.getValue(paramNode, new Vector(), this.symTab);
|
|
}
|
|
|
|
public double getValue() {
|
|
Object object = getValueAsObject();
|
|
if (object == null)
|
|
return Double.NaN;
|
|
if (object instanceof Complex) {
|
|
Complex complex = (Complex)object;
|
|
return (complex.im() != 0.0D) ? Double.NaN : complex.re();
|
|
}
|
|
return (object != null && object instanceof Number) ? ((Number)object).doubleValue() : Double.NaN;
|
|
}
|
|
|
|
public Complex getComplexValue() {
|
|
Object object = getValueAsObject();
|
|
return (object == null) ? null : ((object instanceof Complex) ? (Complex)object : ((object instanceof Number) ? new Complex(((Number)object).doubleValue(), 0.0D) : null));
|
|
}
|
|
|
|
public Object getValueAsObject() {
|
|
if (this.topNode != null && !hasError()) {
|
|
Object object;
|
|
try {
|
|
object = this.ev.getValue(this.topNode, this.errorList, this.symTab);
|
|
} catch (Exception exception) {
|
|
this.errorList.addElement("Error during evaluation");
|
|
return null;
|
|
}
|
|
return object;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public boolean hasError() {
|
|
return !this.errorList.isEmpty();
|
|
}
|
|
|
|
public String getErrorInfo() {
|
|
if (hasError()) {
|
|
String str = "";
|
|
for (byte b = 0; b < this.errorList.size(); b++)
|
|
str = str + this.errorList.elementAt(b) + "\n";
|
|
return str;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Node getTopNode() {
|
|
return this.topNode;
|
|
}
|
|
|
|
public SymbolTable getSymbolTable() {
|
|
return this.symTab;
|
|
}
|
|
|
|
public FunctionTable getFunctionTable() {
|
|
return this.funTab;
|
|
}
|
|
|
|
public NumberFactory getNumberFactory() {
|
|
return this.numberFactory;
|
|
}
|
|
|
|
public OperatorSet getOperatorSet() {
|
|
return this.opSet;
|
|
}
|
|
|
|
public Parser getParser() {
|
|
return this.parser;
|
|
}
|
|
}
|