Expression parsing using binary operators

Question

I'm trying to figure out ways to parse an expression that uses all binary operators. Each operator is surrounded by exactly one set of parenthesis, such that:

5x^2 + 3x + 2

would be

((5*(x^2))+((3*x)+2))

and is taken as an args[] argument (more importantly, it is given as a String).

I'm recursively breaking this down, where each recursion breaks down the left part of the top binary operator and call the recursion with that expression as an argument, then again with the right. The base case is when the expression being passed contains no operators.

The problem I'm having is appropriately parsing the left side from the right side. I am trying to develop a way based upon a Scanner that counts the number of parenthesis counted overall, but can't seem to determine a final solution. Anyone have an idea how to parse this correctly in order to pass it as an expression to the recursive method.

P.s. - Language I am using is Java

EDIT::::

I am using this parser as a part of a GUI graph plotter, so I would set the variable (x) based on what value of the x-axis I am currently looking to generate on the GUI graph. So, the expression being parsed within the program (as shown in the second code tag above) would be broken down and operated on to produce a final "y" value that would correlate to the position on the window where a small dot would be used to represent that point on the line of the graph.

Maybe this will better explain how I am trying to use this.

Are you saying your input actually looks like your second example? Or that you need to process your first example as though it looked like your second? — corsiKa, Sep 15 '11 at 22:48
I'm saying the second is the string you are given. In the end, you want to solve the equation (where x is assigned a value). but to do that, you must first break down all the pieces (the recursion part). — dcfc_rph, Sep 15 '11 at 22:58
I'm somewhat confused - so you're building a parse tree and use that to solve the equation. What exactly is your question? — Voo, Sep 15 '11 at 23:08
@Voo So I guess the question would be how would you determine that the expression should be split around the "+" that is dead in the middle in order to be further broken down until just values/variables are reached. — dcfc_rph, Sep 15 '11 at 23:25

score 2 · Answer 1 · answered Sep 15 '11 at 23:07

2

I would start with an element class

interface Element {

}

And two elements

abstract class Operator implements Element {

    Operand operate(Operand a, Operand b);

}

class Operand implements Element {
    int value;
    Operand(int value) { this.value = value; }
}

Now you can create your Operator factory

class OperatorFactory {
    Operator createOperator(String symbol) {
         if("+".equals(symbol)) 
             return new Operator() {
                 Operator operate(Operand a, Operand b) { 
                     return new Operand(a.value + b.value);
                 }
             };
         if("-".equals(symbol)) /* continued */
    }
}

Now you're able to make yourself a stack processor that recurs when you reach a "(" and operates when you reach a ")". I imagine the rest will be pretty trivial from there.

answered Sep 15 '11 at 23:07

corsiKa

81,495
25
153
204

1

And for some more help, you should look at the [shunting yard algorithm](http://en.wikipedia.org/wiki/Shunting_yard_algorithm) - a classic with a pretty wide range of possible applications (I used it once to create a regular expression state machine). – Voo Sep 15 '11 at 23:51
@Voo I really like that link. I'm going to add that to my "$#!^ I need to know to solve problems" bag. – corsiKa Sep 16 '11 at 00:01
See now that works when it is down to just one binary operator. If it is complex (like the example in code tags given in original post), how do you decompose that into its smaller parts? – dcfc_rph Sep 16 '11 at 02:51

score 1 · Answer 2 · answered Sep 15 '11 at 23:43

What you want to implement is a simple recursive descent parser, which means that each production of your grammar will turn into a recursive function probably similar to what you're currently doing.

I don't know if you're familiar with the BNF syntax but here is one possible grammar for your language of binary operators. I'm omitting the power operator, which I leave for you to implement.

Expression ::= Expression + Term
Expression ::= Expression - Term
Expression ::= Term

Term ::= Term * Factor
Term ::= Term / Factor
Term ::= Factor

Factor ::= number
Factor ::= ( Expression )

With that you can see that you're defining an Expression by using an Expression, hence the use of recursive functions.

Please read this Wikipedia link and you'll immediately see how to implement what you want. http://en.wikipedia.org/wiki/Recursive_descent_parser

score 0 · Answer 3 · answered Sep 15 '11 at 22:50

0

Is your problem with logic or code?

In your logic, only issue I see is the precedence and associativity should also be considered (depending on the operator).

If the problem is with code, can you post the code? Also an example with teh expected output vs actual output would help so I don't have to put it in eclipse and run it myself.

answered Sep 15 '11 at 22:50

Kashyap

15,354
13
64
103

I'm having trouble developing any ideas into how I could do this with Java without having stupid amounts of excess code. – dcfc_rph Sep 15 '11 at 22:59

Expression parsing using binary operators

3 Answers3