Evaluating Math Expressions in Strings

Evaluating math expressions given as strings is a common task in many applications, including calculators, spreadsheet software, and programming languages. In this tutorial, we will explore how to achieve this using Java.

Introduction to Math Expression Evaluation

Math expression evaluation involves taking a string that represents a mathematical expression, parsing it, and then calculating the result. For example, given the string "5+3", we would parse it as an addition operation between 5 and 3, and then calculate the result, which is 8.

Using Java’s Built-in Script Engine

One way to evaluate math expressions in Java is by using the built-in JavaScript engine. This approach allows us to leverage the JavaScript engine’s ability to execute scripts, including mathematical expressions.

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class MathExpressionEvaluator {
    public static void main(String[] args) throws ScriptException {
        ScriptEngineManager mgr = new ScriptEngineManager();
        ScriptEngine engine = mgr.getEngineByName("JavaScript");
        String expression = "40+2";
        System.out.println(engine.eval(expression));
    }
}

Implementing a Recursive Descent Parser

While using the JavaScript engine is convenient, it may not be suitable for all applications. An alternative approach is to implement a recursive descent parser, which is a type of top-down parser that uses a set of recursive functions to parse the input string.

A recursive descent parser works by defining a grammar for the math expressions we want to support, and then implementing a set of functions that correspond to each production in the grammar. For example, if our grammar includes productions for addition and multiplication, we would implement separate functions for parsing these operations.

Here is an example implementation of a recursive descent parser in Java:

public class RecursiveDescentParser {
    private int pos;
    private char[] input;

    public RecursiveDescentParser(String input) {
        this.input = input.toCharArray();
        this.pos = 0;
    }

    public double parse() {
        return parseExpression();
    }

    private double parseExpression() {
        double result = parseTerm();
        while (pos < input.length && (input[pos] == '+' || input[pos] == '-')) {
            char op = input[pos];
            pos++;
            double term = parseTerm();
            if (op == '+') {
                result += term;
            } else {
                result -= term;
            }
        }
        return result;
    }

    private double parseTerm() {
        double result = parseFactor();
        while (pos < input.length && (input[pos] == '*' || input[pos] == '/')) {
            char op = input[pos];
            pos++;
            double factor = parseFactor();
            if (op == '*') {
                result *= factor;
            } else {
                result /= factor;
            }
        }
        return result;
    }

    private double parseFactor() {
        if (input[pos] == '(') {
            pos++;
            double result = parseExpression();
            pos++; // skip ')'
            return result;
        } else if (Character.isDigit(input[pos])) {
            int start = pos;
            while (pos < input.length && Character.isDigit(input[pos])) {
                pos++;
            }
            return Double.parseDouble(new String(input, start, pos - start));
        } else {
            throw new RuntimeException("Invalid character: " + input[pos]);
        }
    }
}

Using a Third-Party Library

Another option is to use a third-party library that provides math expression evaluation capabilities. One such library is mXparser, which supports a wide range of mathematical functions and operations.

Here is an example of how to use mXparser to evaluate a math expression:

import org.mariuszgromada.math.mxparser.Expression;

public class MathExpressionEvaluator {
    public static void main(String[] args) {
        Expression e = new Expression("(2 + 3/4 + sin(pi))/2");
        double result = e.calculate();
        System.out.println(result);
    }
}

Conclusion

Evaluating math expressions in strings is a common task that can be achieved using various approaches, including Java’s built-in script engine, recursive descent parsers, and third-party libraries. The choice of approach depends on the specific requirements of your application, including performance, flexibility, and ease of use.

By following this tutorial, you should now have a good understanding of how to evaluate math expressions in strings using Java.