How to evaluate a math expression given in string form

Question

I m trying to write a Java routine to evaluate math expressions from String values like    quot 5 3 quot   quot 10-40 quot   quot  1 10  3 quot   I want to avoid a lot of if-then-else statements  How can I do this

User · Answer

Try the following sample code using JDK1 6 s Javascript engine with code injection handling   import javax script ScriptEngine  import javax script ScriptEngineManager   public class EvalUtil   private static ScriptEngine engine   new ScriptEngineManager   getEngineByName  JavaScript    public static void main String   args        try           System out println  new EvalUtil    eval     5 5  2   gt  5     5  gt 3              System out println  new EvalUtil    eval     5 5  2   gt  5     true           catch  Exception e            e printStackTrace            public Object eval String input  throws Exception      try           if input matches     a-zA-Z                                                    throw new Exception  Invalid expression       input                      return engine eval input         catch  Exception e            e printStackTrace            throw e

User · Answer

You can evaluate expressions easily if your Java application already accesses a database  without using any other JARs   Some databases require you to use a dummy table  eg  Oracle s  dual  table  and others will allow you to evaluate expressions without  selecting  from any table   For example  in Sql Server or Sqlite  select    12 10  12 0    233 0  amount   and in Oracle  select    12 10  12 0    233 0  amount from dual    The advantage of using a DB is that you can evaluate many expressions at the same time  Also most DB s will allow you to use highly complex expressions and   will also have a number of extra functions that can be called as necessary     However performance may suffer if many single expressions need to be evaluated individually  particularly when the DB is located on a network server   The following addresses the performance problem to some extent  by using a Sqlite in-memory database       Here s a full working example in Java  Class  forName  org sqlite JDBC    Connection conn   DriverManager getConnection  jdbc sqlite  memory     Statement stat   conn createStatement    ResultSet rs   stat executeQuery   select  1 10  20 0 amount    rs next    System out println rs getBigDecimal 1    stat close    conn close      Of course you could extend the above code to handle multiple calculations at the same time   ResultSet rs   stat executeQuery   select  1 10  20 0 amount   1 100  20 0 amount2

User · Answer

package ExpressionCalculator expressioncalculator   import java text DecimalFormat  import java util Scanner   public class ExpressionCalculator    private static String addSpaces String exp          Add space padding to operands        https   regex101 com r sJ9gM7 73     exp   exp replaceAll     lt   0-9                        exp   exp replaceAll     lt   0-9                        exp   exp replaceAll     lt   0-9                        exp   exp replaceAll     lt   0-9                       exp   exp replaceAll     lt   0-9     -      -            Keep replacing double spaces with single spaces until your string is properly formatted       while exp indexOf          -1           exp   exp replace                          exp   exp replaceAll    2                   return exp     public static Double evaluate String expr        DecimalFormat df   new DecimalFormat                   Format the expression properly before performing operations     String expression   addSpaces expr        try             We will evaluate using rule BDMAS  i e  brackets  division  power  multiplication  addition and           subtraction will be processed in following order         int indexClose   expression indexOf               int indexOpen   -1          if  indexClose    -1                String substring   expression substring 0  indexClose               indexOpen   substring lastIndexOf                   substring   substring substring indexOpen   1  trim                if indexOpen    -1  amp  amp  indexClose    -1                    Double result   evaluate substring                   expression   expression substring 0  indexOpen  trim           result         expression substring indexClose   1  trim                    return evaluate expression trim                                      String operation               if expression indexOf           -1               operation                 else if expression indexOf           -1               operation                  else if expression indexOf           -1               operation                  else if expression indexOf           -1               operation                  else if expression indexOf   -       -1     Avoid negative numbers             operation    -             else              return Double parseDouble expression                      int index   expression indexOf operation           if index    -1               indexOpen   expression lastIndexOf      index - 2               indexOpen    indexOpen    -1  0 indexOpen              indexClose   expression indexOf      index   2               indexClose    indexClose    -1  expression length   indexClose              if indexOpen    -1  amp  amp  indexClose    -1                    Double lhs   Double parseDouble expression substring indexOpen  index                    Double rhs   Double parseDouble expression substring index   2  indexClose                    Double result   null                  switch  operation                       case                                Prevent divide by 0 exception                          if rhs    0                               return null                                                    result   lhs   rhs                          break                      case                              result   Math pow lhs  rhs                           break                      case                              result   lhs   rhs                          break                      case  -                           result   lhs - rhs                          break                      case                              result   lhs   rhs                          break                      default                          break                                    if indexClose    expression length                         expression   expression substring 0  indexOpen          result         expression substring indexClose                    else                      expression   expression substring 0  indexOpen          result         expression substring indexClose   1                                     return Double valueOf df format evaluate expression trim                                    catch Exception exp           exp printStackTrace              return 0 0     public static void main String args          Scanner scanner   new Scanner System in       System out print  Enter an Mathematical Expression to Evaluate          String input   scanner nextLine        System out println evaluate input

User · Answer

This is actually complementing the answer given by  Boann  It has a slight bug which causes  -2   2  to give an erroneous result of -4 0  The problem for that is the point at which the exponentiation is evaluated in his  Just move the exponentiation to the block of parseTerm    and you ll be all fine  Have a look at the below  which is  Boann s answer slightly modified  Modification is in the comments   public static double eval final String str        return new Object             int pos   -1  ch           void nextChar                 ch      pos  lt  str length      str charAt pos    -1                     boolean eat int charToEat                while  ch         nextChar                if  ch    charToEat                    nextChar                    return true                            return false                     double parse                 nextChar                double x   parseExpression                if  pos  lt  str length    throw new RuntimeException  Unexpected       char ch               return x                        Grammar             expression   term   expression     term   expression  -  term            term   factor   term     factor   term     factor            factor       factor    -  factor       expression                         number   functionName factor   factor     factor          double parseExpression                 double x   parseTerm                for                        if       eat       x    parseTerm       addition                 else if  eat  -    x -  parseTerm       subtraction                 else return x                                   double parseTerm                 double x   parseFactor                for                        if       eat       x    parseFactor       multiplication                 else if  eat       x    parseFactor       division                 else if  eat       x   Math pow x  parseFactor       exponentiation - gt  Moved in to here  So the problem is fixed                 else return x                                   double parseFactor                 if  eat       return parseFactor       unary plus             if  eat  -    return -parseFactor       unary minus              double x              int startPos   this pos              if  eat            parentheses                 x   parseExpression                    eat                     else if   ch  gt    0   amp  amp  ch  lt    9      ch              numbers                 while   ch  gt    0   amp  amp  ch  lt    9      ch         nextChar                    x   Double parseDouble str substring startPos  this pos                  else if  ch  gt    a   amp  amp  ch  lt    z        functions                 while  ch  gt    a   amp  amp  ch  lt    z   nextChar                    String func   str substring startPos  this pos                   x   parseFactor                    if  func equals  sqrt    x   Math sqrt x                   else if  func equals  sin    x   Math sin Math toRadians x                    else if  func equals  cos    x   Math cos Math toRadians x                    else if  func equals  tan    x   Math tan Math toRadians x                    else throw new RuntimeException  Unknown function      func                 else                   throw new RuntimeException  Unexpected       char ch                                if  eat       x   Math pow x  parseFactor        exponentiation - gt  This is causing a bit of problem              return x                  parse

User · Answer

How about something like this   String st    10 3   int result  for int i 0 i lt st length   i        if st charAt i                result Integer parseInt st substring 0  i   Integer parseInt st substring i 1  st length          System out print result                    and do the similar thing for every other mathematical operator accordingly

User · Answer

You might have a look at the Symja framework   ExprEvaluator util   new ExprEvaluator     IExpr result   util evaluate  10-40    System out println result toString        - gt   -30     Take note that definitively more complex expressions can be evaluated      D      gives the derivative of the function Sin x  Cos x  IAST function   D Times Sin x   Cos x    x   IExpr result   util evaluate function      print  Cos x  2-Sin x  2

User · Answer

External library like RHINO or NASHORN can be used to run javascript  And javascript can evaluate simple formula without parcing the string  No performance impact as well if code is written well  Below is an example with RHINO -   public class RhinoApp       private String simpleAdd     12 13 2-2  2  12 13 2-2  2    public void runJavaScript         Context jsCx   Context enter        Context getCurrentContext   setOptimizationLevel -1       ScriptableObject scope   jsCx initStandardObjects        Object result   jsCx evaluateString scope  simpleAdd    formula   0  null       Context exit        System out println result

User · Answer

It is possible to convert any expression string in infix notation to a postfix notation using Djikstra s shunting-yard algorithm  The result of the algorithm can then serve as input to the postfix algorithm with returns the result of the expression   I wrote an article about it here  with an implementation in java

User · Answer

With JDK1 6  you can use the built-in Javascript engine   import javax script ScriptEngineManager  import javax script ScriptEngine  import javax script ScriptException   public class Test     public static void main String   args  throws ScriptException       ScriptEngineManager mgr   new ScriptEngineManager        ScriptEngine engine   mgr getEngineByName  JavaScript        String foo    40 2       System out println engine eval foo

User · Answer

HERE is another open source library on GitHub named EvalEx   Unlike the JavaScript engine this library is focused in evaluating mathematical expressions only  Moreover  the library is extensible and supports use of boolean operators as well as parentheses

User · Answer

It s too late to answer but I came across same situation to evaluate expression in java  it might help someone  MVEL does runtime evaluation of expressions  we can write a java code in String to get it evaluated in this       String expressionStr    x y       Map lt String  Object gt  vars   new HashMap lt String  Object gt         vars put  x   10       vars put  y   20       ExecutableStatement statement    ExecutableStatement  MVEL compileExpression expressionStr       Object result   MVEL executeExpression statement  vars

User · Answer

This is another interesting alternative  https   github com Shy-Ta expression-evaluator-demo  The usage is very simple and gets the job done  for example     ExpressionsEvaluator evalExpr   ExpressionsFactory create  2 3 4-6 2        assertEquals BigDecimal valueOf 11   evalExpr eval

User · Answer

I m using this  But if there are any better methods in java please let me know  import javax script ScriptEngine  import javax script ScriptEngineManager  import javax script ScriptException   public class test2       public static void main String   args  throws ScriptException           String s    quot 10 2 quot           ScriptEngineManager mn   new ScriptEngineManager            ScriptEngine en   mn getEngineByName  quot js quot            Object result   en eval s           System out println result

User · Answer

Yet another option  https   github com stefanhaustein expressionparser  I have implemented this to have a simple but flexible option to permit both    Immediate processing  Calculator java  SetDemo java  Building and processing a parse tree  TreeBuilder java    The TreeBuilder linked above is part of a CAS demo package that does symbolic derivation  There is also a BASIC interpreter example and I have started to build a TypeScript interpreter using it

User · Answer

Another way is to use Spring Expression Language or SpEL which does a whole lot more along with evaluating mathematical expressions therefore maybe slightly overkill  You do not have to be using Spring framework to use this expression library as it is stand-alone  Copying examples from SpEL s documentation    ExpressionParser parser   new SpelExpressionParser    int two   parser parseExpression  1   1   getValue Integer class      2  double twentyFour   parser parseExpression  2 0   3e0   4   getValue Double class     24 0   Read more concise SpEL examples here and the complete docs here

User · Answer

import java util     public class check       int ans     String str  7   5      StringTokenizer st new StringTokenizer str       int v1 Integer parseInt st nextToken        String op st nextToken       int v2 Integer parseInt st nextToken         if op equals         ans  v1   v2       if op equals  -      ans  v1 - v2

User · Answer

You can also try the BeanShell interpreter   Interpreter interpreter   new Interpreter    interpreter eval  result    7 21 6   32-27     System out println interpreter get  result

User · Answer

if we are going to implement it then we can can use the below algorithm  --   While there are still tokens to be read in   1 1 Get the next token  1 2 If the token is   1 2 1 A number  push it onto the value stack   1 2 2 A variable  get its value  and push onto the value stack   1 2 3 A left parenthesis  push it onto the operator stack   1 2 4 A right parenthesis    1 While the thing on top of the operator stack is not a     left parenthesis       1 Pop the operator from the operator stack       2 Pop the value stack twice  getting two operands       3 Apply the operator to the operands  in the correct order       4 Push the result onto the value stack   2 Pop the left parenthesis from the operator stack  and discard it    1 2 5 An operator  call it thisOp     1 While the operator stack is not empty  and the top thing on the    operator stack has the same or greater precedence as thisOp     1 Pop the operator from the operator stack     2 Pop the value stack twice  getting two operands     3 Apply the operator to the operands  in the correct order     4 Push the result onto the value stack   2 Push thisOp onto the operator stack   While the operator stack is not empty  1 Pop the operator from the operator stack  2 Pop the value stack twice  getting two operands  3 Apply the operator to the operands  in the correct order  4 Push the result onto the value stack  At this point the operator stack should be empty  and the value stack should have only one value in it  which is the final result

User · Answer

This article discusses various approaches  Here are the 2 key approaches mentioned in the article  JEXL from Apache Allows for scripts that include references to java objects     Create or retrieve a JexlEngine JexlEngine jexl   new JexlEngine       Create an expression object String jexlExp    quot foo innerFoo bar   quot   Expression e   jexl createExpression  jexlExp         Create a context and add data JexlContext jctx   new MapContext    jctx set  quot foo quot   new Foo           Now evaluate the expression  getting the result Object o   e evaluate jctx    Use the javascript engine embedded in the JDK  private static void jsEvalWithVariable         List lt String gt  namesList   new ArrayList lt String gt         namesList add  quot Jill quot        namesList add  quot Bob quot        namesList add  quot Laureen quot        namesList add  quot Ed quot          ScriptEngineManager mgr   new ScriptEngineManager        ScriptEngine jsEngine   mgr getEngineByName  quot JavaScript quot          jsEngine put  quot namesListKey quot   namesList       System out println  quot Executing in script environment    quot        try             jsEngine eval  quot var x  quot                         quot var names   namesListKey toArray    quot                         quot for x in names    quot                         quot   println names x    quot                         quot   quot                         quot namesListKey add   quot Dana  quot    quot              catch  ScriptException ex                ex printStackTrace

User · Answer

The correct way to solve this is with a lexer and a parser  You can write simple versions of these yourself  or those pages also have links to Java lexers and parsers   Creating a recursive descent parser is a really good learning exercise

User · Answer

It seems like JEP should do the job

User · Answer

I think what ever way you do this it s going to involve a lot of conditional statements  But for single operations like in your examples you could limit it to 4 if statements with something like   String math    1 4    if  math split      length    2          do calculation   else if  math split  -   length    2          do calculation         It gets a whole lot more complicated when you want to deal with multiple operations like  4 5 6    If you are trying to build a calculator then I d surgest passing each section of the calculation separatly  each number or operator  rather than as a single string

User · Answer

For my university project  I was looking for a parser   evaluator supporting both basic formulas and more complicated equations  especially iterated operators   I found very nice open source library for JAVA and  NET called mXparser  I will give a few examples to make some feeling on the syntax  for further instructions please visit project website  especially tutorial section    https   mathparser org   https   mathparser org mxparser-tutorial   https   mathparser org api   And few examples  1 - Simple furmula  Expression e   new Expression    2   3 4   sin pi    2    double v   e calculate     2 - User defined arguments and constants  Argument x   new Argument  x   10    Constant a   new Constant  a   pi 2    Expression e   new Expression  cos a x    x  a   double v   e calculate     3 - User defined functions  Function f   new Function  f x  y  z    sin x    cos y z     Expression e   new Expression  f 3 2 5    f   double v   e calculate     4 - Iteration  Expression e   new Expression  sum  i  1  100  sin i       double v   e calculate     Found recently - in case you would like to try the syntax  and see the advanced use case  you can download the Scalar Calculator app that is powered by mXparser   Best regards

User · Answer

A Java class that can evaluate mathematical expressions   package test   public class Calculator        public static Double calculate String expression           if  expression    null    expression length      0                return null                    return calc expression replace                      public static Double calc String expression             if  expression startsWith       amp  amp  expression endsWith                     return calc expression substring 1  expression length   - 1                      String   containerArr   new String   expression           double leftVal   getNextOperand containerArr           expression   containerArr 0           if  expression length      0                return leftVal                    char operator   expression charAt 0           expression   expression substring 1            while  operator           operator                       containerArr 0    expression              double rightVal   getNextOperand containerArr               expression   containerArr 0               if  operator                           leftVal   leftVal   rightVal                else                   leftVal   leftVal   rightVal                            if  expression length    gt  0                    operator   expression charAt 0                   expression   expression substring 1                 else                   return leftVal                                  if  operator                       return leftVal   calc expression             else               return leftVal - calc expression                         private static double getNextOperand String   exp           double res          if  exp 0  startsWith                     int open   1              int i   1              while  open    0                    if  exp 0  charAt i                                open                      else if  exp 0  charAt i                                open--                                    i                              res   calc exp 0  substring 1  i - 1                exp 0    exp 0  substring i             else               int i   1              if  exp 0  charAt 0      -                     i                              while  exp 0  length    gt  i  amp  amp  isNumber  int  exp 0  charAt i                      i                              res   Double parseDouble exp 0  substring 0  i                exp 0    exp 0  substring i                     return res              private static boolean isNumber int c            int zero    int   0           int nine    int   9           return  c  gt   zero  amp  amp  c  lt   nine     c                   public static void main String   args            System out println calculate       -6        9   -1             System out println calc   -5 2 -5 -5   5 4 2

User · Answer

I ve written this eval method for arithmetic expressions to answer this question  It does addition  subtraction  multiplication  division  exponentiation  using the   symbol   and a few basic functions like sqrt  It supports grouping using        and it gets the operator precedence and associativity rules correct   public static double eval final String str        return new Object             int pos   -1  ch           void nextChar                 ch      pos  lt  str length      str charAt pos    -1                     boolean eat int charToEat                while  ch         nextChar                if  ch    charToEat                    nextChar                    return true                            return false                     double parse                 nextChar                double x   parseExpression                if  pos  lt  str length    throw new RuntimeException  Unexpected       char ch               return x                        Grammar             expression   term   expression     term   expression  -  term            term   factor   term     factor   term     factor            factor       factor    -  factor       expression                         number   functionName factor   factor     factor          double parseExpression                 double x   parseTerm                for                        if       eat       x    parseTerm       addition                 else if  eat  -    x -  parseTerm       subtraction                 else return x                                   double parseTerm                 double x   parseFactor                for                        if       eat       x    parseFactor       multiplication                 else if  eat       x    parseFactor       division                 else return x                                   double parseFactor                 if  eat       return parseFactor       unary plus             if  eat  -    return -parseFactor       unary minus              double x              int startPos   this pos              if  eat            parentheses                 x   parseExpression                    eat                     else if   ch  gt    0   amp  amp  ch  lt    9      ch              numbers                 while   ch  gt    0   amp  amp  ch  lt    9      ch         nextChar                    x   Double parseDouble str substring startPos  this pos                  else if  ch  gt    a   amp  amp  ch  lt    z        functions                 while  ch  gt    a   amp  amp  ch  lt    z   nextChar                    String func   str substring startPos  this pos                   x   parseFactor                    if  func equals  sqrt    x   Math sqrt x                   else if  func equals  sin    x   Math sin Math toRadians x                    else if  func equals  cos    x   Math cos Math toRadians x                    else if  func equals  tan    x   Math tan Math toRadians x                    else throw new RuntimeException  Unknown function      func                 else                   throw new RuntimeException  Unexpected       char ch                              if  eat       x   Math pow x  parseFactor        exponentiation              return x                  parse        Example   System out println eval    4 - 2 3   1    -sqrt 3 3 4 4     2       Output  7 5  which is correct     The parser is a recursive descent parser  so internally uses separate parse methods for each level of operator precedence in its grammar  I kept it short so it s easy to modify  but here are some ideas you might want to expand it with    Variables   The bit of the parser that reads the names for functions can easily be changed to handle custom variables too  by looking up names in a variable table passed to the eval method  such as a Map lt String Double gt  variables  Separate compilation and evaluation   What if  having added support for variables  you wanted to evaluate the same expression millions of times with changed variables  without parsing it every time  It s possible  First define an interface to use to evaluate the precompiled expression    FunctionalInterface interface Expression       double eval        Now change all the methods that return doubles  so instead they return an instance of that interface  Java 8 s lambda syntax works great for this  Example of one of the changed methods   Expression parseExpression         Expression x   parseTerm        for                if  eat            addition             Expression a   x  b   parseTerm                x       - gt  a eval     b eval               else if  eat  -         subtraction             Expression a   x  b   parseTerm                x       - gt  a eval   - b eval               else               return x                      That builds a recursive tree of Expression objects representing the compiled expression  an abstract syntax tree   Then you can compile it once and evaluate it repeatedly with different values   public static void main String   args        Map lt String Double gt  variables   new HashMap lt  gt         Expression exp   parse  x 2 - x   2   variables       for  double x   -20  x  lt    20  x              variables put  x   x           System out println x       gt      exp eval              Different datatypes   Instead of double  you could change the evaluator to use something more powerful like BigDecimal  or a class that implements complex numbers  or rational numbers  fractions   You could even use Object  allowing some mix of datatypes in expressions  just like a real programming language         All code in this answer released to the public domain  Have fun

[java] How to evaluate a math expression given in string form?

Examples related to java

Examples related to string

Examples related to math