exp4j

https://www.objecthunter.net/exp4j/
Admin
exp4j is a lightweight Java library for evaluating mathematical expressions and functions using...
Tokens:3,063
Snippets:46
Trust Score:4.2
Update:6 months ago
Show doc for...
Tokens:
Raw
### Include exp4j via Apache Maven

Source: https://www.objecthunter.net/exp4j/download.html

Add this dependency block to your project's pom.xml file to include the exp4j library.

```xml
<dependency>
        <groupId>net.objecthunter</groupId>
        <artifactId>exp4j</artifactId>
        <version>0.4.8</version>
</dependency>
```

--------------------------------

### Create Custom Logarithm Base Function

Source: https://www.objecthunter.net/exp4j/index.html

Implement a custom function to calculate the logarithm to an arbitrary base using the change of base formula. This function requires two arguments: the value and the base.

```java
Function logb = new Function("logb", 2) {
    @Override
    public double apply(double... args) {
        return Math.log(args[0]) / Math.log(args[1]);
    }
};
double result = new ExpressionBuilder("logb(8, 2)")
        .function(logb)
        .build()
        .evaluate();
double expected = 3;
assertEquals(expected, result, 0d);
```

--------------------------------

### Use Built-in Numerical Constants

Source: https://www.objecthunter.net/exp4j/index.html

exp4j automatically binds common constants like pi (π), e (Euler's number), and φ (golden ratio). These can be used directly in expressions.

```java
String expr = "pi+π+e+φ";
double expected = 2*Math.PI + Math.E + 1.61803398874d;
Expression e = new ExpressionBuilder(expr).build();
assertEquals(expected, e.evaluate(),0d);
```

--------------------------------

### Evaluate a Simple Expression

Source: https://www.objecthunter.net/exp4j/index.html

Use ExpressionBuilder to create an Expression object for evaluation. Variables can be set on the built expression.

```java
Expression e = new ExpressionBuilder("3 * sin(y) - 2 / (x - 2)")
        .variables("x", "y")
        .build()
        .setVariable("x", 2.3)
        .setVariable("y", 3.14);
double result = e.evaluate();
```

--------------------------------

### Use Scientific Notation in Expression

Source: https://www.objecthunter.net/exp4j/index.html

Demonstrates parsing and evaluating an expression containing a number in scientific notation. Ensure the input string is a valid number format.

```java
String expr = "7.2973525698e-3";
double expected = Double.parseDouble(expr);
Expression e = new ExpressionBuilder(expr).build();
assertEquals(expected, e.evaluate(),0d);
```

--------------------------------

### Create Custom Average Function

Source: https://www.objecthunter.net/exp4j/index.html

Define a custom function that calculates the average of four input values. This demonstrates creating multi-argument functions by specifying the argument count in the Function constructor.

```java
Function avg = new Function("avg", 4) {

    @Override
    public double apply(double... args) {
        double sum = 0;
        for (double arg : args) {
            sum += arg;
        }
        return sum / args.length;
    }
};
double result = new ExpressionBuilder("avg(1,2,3,4)")
        .function(avg)
        .build()
        .evaluate();

double expected = 2.5d;
assertEquals(expected, result, 0d);
```

--------------------------------

### Use Implicit Multiplication

Source: https://www.objecthunter.net/exp4j/index.html

exp4j supports implicit multiplication, interpreting adjacent terms like '2cos(xy)' as '2*cos(x*y)'. Ensure variables are declared and set.

```java
double result = new ExpressionBuilder("2cos(xy)")
        .variables("x","y")
        .build()
        .setVariable("x", 0.5d)
        .setVariable("y", 0.25d)
        .evaluate();
assertEquals(2d * Math.cos(0.5d * 0.25d), result, 0d);
```

--------------------------------

### Implement Custom Operator for Division by Zero Handling

Source: https://www.objecthunter.net/exp4j/index.html

Define a custom operator to intercept division by zero and throw an ArithmeticException. This is useful for specific mathematical contexts where such an operation needs explicit handling.

```java
Operator reciprocal = new Operator("$", 1, true, Operator.PRECEDENCE_DIVISION) {
    @Override
    public double apply(final double... args) {
        if (args[0] == 0d) {
            throw new ArithmeticException("Division by zero!");
        }
        return 1d / args[0];
    }
};
Expression e = new ExpressionBuilder("0$").operator(reciprocal).build();
e.evaluate(); // <- this call will throw an ArithmeticException
```

--------------------------------

### Create Custom Factorial Operator

Source: https://www.objecthunter.net/exp4j/index.html

Implement a custom factorial operator '!' that calculates the factorial of an integer. This operator is left-associative and has a precedence higher than exponentiation. It includes validation for integer and non-negative operands.

```java
Operator factorial = new Operator("!", 1, true, Operator.PRECEDENCE_POWER + 1) {

    @Override
    public double apply(double... args) {
        final int arg = (int) args[0];
        if ((double) arg != args[0]) {
            throw new IllegalArgumentException("Operand for factorial has to be an integer");
        }
        if (arg < 0) {
            throw new IllegalArgumentException("The operand of the factorial can not be less than zero");
        }
        double result = 1;
        for (int i = 1; i <= arg; i++) {
            result *= i;
        }
        return result;
    }
};

double result = new ExpressionBuilder("3!")
        .operator(factorial)
        .build()
        .evaluate();

double expected = 6d;
assertEquals(expected, result, 0d);
```

--------------------------------

### Evaluate an Expression Asynchronously

Source: https://www.objecthunter.net/exp4j/index.html

Evaluate expressions asynchronously by providing an ExecutorService to the evaluateAsync method. This returns a Future object.

```java
ExecutorService exec = Executors.newFixedThreadPool(1);
Expression e = new ExpressionBuilder("3log(y)/(x+1)")
        .variables("x", "y")
        .build()
        .setVariable("x", 2.3)
        .setVariable("y", 3.14);
Future<Double> future = e.evaluateAsync(exec);
double result = future.get();
```

--------------------------------

### Create Custom Greater Than or Equal To Operator

Source: https://www.objecthunter.net/exp4j/index.html

Define a custom logical operator '>=' that returns 1 if the first operand is greater than or equal to the second, and 0 otherwise. This operator is left-associative and has a precedence lower than addition.

```java
@Test
public void testOperators3() throws Exception {
    Operator gteq = new Operator(">=", 2, true, Operator.PRECEDENCE_ADDITION - 1) {

        @Override
        public double apply(double[] values) {
            if (values[0] >= values[1]) {
                return 1d;
            } else {
                return 0d;
            }
        }
    };

    Expression e = new ExpressionBuilder("1>=2").operator(gteq)
            .build();
    assertTrue(0d == e.evaluate());
    e = new ExpressionBuilder("2>=1").operator(gteq)
            .build();
    assertTrue(1d == e.evaluate());
}
```

--------------------------------

### Validate an Expression

Source: https://www.objecthunter.net/exp4j/index.html

Validate an expression to check for correctness and ensure all variables are set. The `validate()` method returns a `ValidationResult` object containing validity status and any errors.

```java
Expression e = new ExpressionBuilder("x")
        .variable("x")
        .build();

ValidationResult res = e.validate();
assertFalse(res.isValid());
assertEquals(1, res.getErrors().size());

e.setVariable("x",1d);
res = e.validate();
assertTrue(res.isValid());
```

--------------------------------

### Validate Expression Skipping Variable Check

Source: https://www.objecthunter.net/exp4j/index.html

Validate an expression without checking if all variables have been set. This is useful when you want to perform a structural validation before all variables are available.

```java
Expression e = new ExpressionBuilder("x")
        .variable("x")
        .build();

ValidationResult res = e.validate(false);
assertTrue(res.isValid());
assertNull(res.getErrors());
```
Tokens:
Raw