EvalEx is a handy expression evaluator for Java, that allows to evaluate simple mathematical and boolean expressions.
Key Features:
- Uses BigDecimal for calculation and result
- Single class implementation, very compact
- No dependencies to external libraries
- Precision and rounding mode can be set
- Supports variables
- Standard boolean and mathematical operators
- Standard basic mathematical and boolean functions
- Custom functions and operators can be added at runtime
- Functions can be defined with a variable number of arguments (see MIN and MAX functions)
- Supports for hexadecimal numbers and scientific notations of numbers
- Supports string literals in functions
You can download the binaries, source code and JavaDoc jars from Maven Central.
The project and source code in zip and tar.gz format can also be downloaded from the projects release area.
To include it in your Maven project, refer to the artifact in your pom. For example:
</dependencies>
<dependency>
<groupId>com.udojava</groupId>
<artifactId>EvalEx</artifactId>
<version>1.9</version>
</dependency>
</dependencies>If you're using gradle add to your project's app build.gradle:
dependencies {
...
compile 'com.udojava:EvalEx:1.9'
} BigDecimal result = null;
Expression expression = new Expression("1+1/3");
result = expression.eval():
expression.setPrecision(2);
result = expression.eval():
result = new Expression("(3.4 + -4.1)/2").eval();
result = new Expression("SQRT(a^2 + b^2").with("a","2.4").and("b","9.253").eval();
BigDecimal a = new BigDecimal("2.4");
BigDecimal b = new BigDecimal("9.235");
result = new Expression("SQRT(a^2 + b^2").with("a",a).and("b",b).eval();
result = new Expression("2.4/PI").setPrecision(128).setRoundingMode(RoundingMode.UP).eval();
result = new Expression("random() > 0.5").eval();
result = new Expression("not(x<7 || sqrt(max(x,9,3,min(4,3))) <= 3))").with("x","22.9").eval();
result = new Expression("log10(100)").eval();| Mathematical Operators | |
|---|---|
| Operator | Description |
| + | Additive operator / Unary plus |
| - | Subtraction operator / Unary minus |
| * | Multiplication operator |
| / | Division operator |
| % | Remainder operator (Modulo) |
| ^ | Power operator |
| Boolean Operators* | |
|---|---|
| Operator | Description |
| = | Equals |
| == | Equals |
| != | Not equals |
| <> | Not equals |
| < | Less than |
| <= | Less than or equal to |
| > | Greater than |
| >= | Greater than or equal to |
| && | Boolean and |
| || | Boolean or |
| Function* | Description |
|---|---|
| NOT(expression) | Boolean negation, 1 (means true) if the expression is not zero |
| IF(condition,value_if_true,value_if_false) | Returns one value if the condition evaluates to true or the other if it evaluates to false |
| RANDOM() | Produces a random number between 0 and 1 |
| MIN(e1,e2, ...) | Returns the smallest of the given expressions |
| MAX(e1,e2, ...) | Returns the biggest of the given expressions |
| ABS(expression) | Returns the absolute (non-negative) value of the expression |
| ROUND(expression,precision) | Rounds a value to a certain number of digits, uses the current rounding mode |
| FLOOR(expression) | Rounds the value down to the nearest integer |
| CEILING(expression) | Rounds the value up to the nearest integer |
| LOG(expression) | Returns the natural logarithm (base e) of an expression |
| LOG10(expression) | Returns the common logarithm (base 10) of an expression |
| SQRT(expression) | Returns the square root of an expression |
| SIN(expression) | Returns the trigonometric sine of an angle (in degrees) |
| COS(expression) | Returns the trigonometric cosine of an angle (in degrees) |
| TAN(expression) | Returns the trigonometric tangens of an angle (in degrees) |
| ASIN(expression) | Returns the angle of asin (in degrees) |
| ACOS(expression) | Returns the angle of acos (in degrees) |
| ATAN(expression) | Returns the angle of atan (in degrees) |
| SINH(expression) | Returns the hyperbolic sine of a value |
| COSH(expression) | Returns the hyperbolic cosine of a value |
| TANH(expression) | Returns the hyperbolic tangens of a value |
| RAD(expression) | Converts an angle measured in degrees to an approximately equivalent angle measured in radians |
| DEG(expression) | Converts an angle measured in radians to an approximately equivalent angle measured in degrees |
| Constant | Description |
|---|---|
| e | The value of e, exact to 70 digits |
| PI | The value of PI, exact to 100 digits |
| TRUE | The value one |
| FALSE | The value zero |
| NULL | The null value |
Custom operators can be added easily, simply create an instance of Expression.Operator and add it to the expression.
Parameters are the operator string, its precedence and if it is left associative. The operators eval() method will be called with the BigDecimal values of the operands.
All existing operators can also be overridden.
For example, add an operator x >> n, that moves the decimal point of x n digits to the right:
Expression e = new Expression("2.1234 >> 2");
e.addOperator(e.new Operator(">>", 30, true) {
@Override
public BigDecimal eval(BigDecimal v1, BigDecimal v2) {
return v1.movePointRight(v2.toBigInteger().intValue());
}
});
e.eval(); // returns 212.34Adding custom functions is as easy as adding custom operators. Create an instance of Expression.Functionand add it to the expression.
Parameters are the function name and the count of required parameters. The functions eval() method will be called with a list of the BigDecimal parameters.
A -1 as the number of parameters denotes a variable number of arguments.
All existing functions can also be overridden.
For example, add a function average(a,b,c), that will calculate the average value of a, b and c:
Expression e = new Expression("2 * average(12,4,8)");
e.addFunction(e.new Function("average", -1) {
@Override
public BigDecimal eval(List<BigDecimal> parameters) {
if (parameters.size() == 0) {
throw new ExpressionException("average requires at least one parameter");
}
BigDecimal avg = new BigDecimal(0);
for (BigDecimal parameter : parameters) {
avg = avg.add(parameter);
}
return avg.divide(new BigDecimal(parameters.size()));
}
});
e.eval(); // returns 16You can create a custom function with string parameters. Create an instance of Expression.LazyFunctionand add it to the expression.
Parameters are the function name and the count of required parameters. The functions lazyEval() method will be called with a list of the LazyNumber parameters.
A -1 as the number of parameters denotes a variable number of arguments. String parameters needs to be surrounded by ".
For example, add a function STREQ("string1","string2"), that will compare whether string1 and string2 are equal:
Expression e = new Expression("STREQ(\"test\", \"test2\")");
e.addLazyFunction(e.new LazyFunction("STREQ", 2) {
private LazyNumber ZERO = new LazyNumber() {
public BigDecimal eval() {
return BigDecimal.ZERO;
}
public String getString() {
return "0";
}
};
private LazyNumber ONE = new LazyNumber() {
public BigDecimal eval() {
return BigDecimal.ONE;
}
public String getString() {
return null;
}
};
@Override
public LazyNumber lazyEval(List<LazyNumber> lazyParams) {
if (lazyParams.get(0).getString().equals(lazyParams.get(1).getString())) {
return ZERO;
}
return ONE;
}
});
e.eval(); // returns 1The software was created and tested using Java 1.6.0.
src/ The Java sources
tests/ JUnit tests
Copyright 2012-2017 by Udo Klimaschewski
http://about.me/udo.klimaschewski
The software is licensed under the MIT Open Source license (see LICENSE file).
- The power of operator (^) implementation was copied from Stack Overflow Thanks to Gene Marin
- The SQRT() function implementation was taken from the book The Java Programmers Guide To numerical Computing (Ronald Mak, 2002)
- Varargs implementation based on "David's method" outlined in Gene Pavlovsky's comment from here