Question

I need to implement the following thing in my web-application. I know my solution is incorrect, but I put the code jsut to demonstrate the idea.

There is a class ‘arc’. I need to be able to assign ANY expression to this arc (e.g. a+b+c,a-c,if-then). Once expression is assigned, I’d like to be able to execute it with some randomly taken variables. Is it possible to implement such functionality in web-applications? Maybe, I should use some plug-in like MathPL? Or maybe there is an absolutely different approach to tackle such kind of problems?

class arc {

    var $arcexpression;

    function setExpression($arcexpression) {
        $this->arcexpression = $arcexpression;
    }

    function getExpression() {
        return $this->arcexpression;
    }


}

$arc = new arc();

$arc->setExpression("if a>b then return a else return b");

$result = $arc->execute(a,b);  // the function 'execute' should be somehow described in 'arc'

Answer 1

You don’t need to implement a whole language for this. I would start by limiting what can be done, for example, limit your expressions to arithmetic operators (+, -, *, /), parentheses and if-then operator. You’ll need to enforce some sort of syntax for if-then to make it easier, possibly, the same as php’s operator ?:. After that you need to build a parser for this grammar only: to parse a given expression into a tree. For example, expression `a + b * c’ would parse into something like this:

  +
 / \
a   *
   / \
  b   c

After that you’ll just have to evaluate such expressions. For example, by passing an array into your evaluate function of type { a => 1, b => 2, c => 3 }, you’ll get 7 out of it.

The idea of the parse is the following:

1. Start from position 1 in the string – and call a recursive function to parse data from that position. In the function, start reading from the specified position.
2. If you read an opening parenthesis, call itself recursively
3. If you encounter a closing parenthesis or end-of-string, return the root node
4. Read the first identifier (or recursively inside parentheses)
5. Read the arithmetic sign
6. Read the second identifier (or recursively inside parentheses)
7. If the sign is * or /, then create the node with the sign in it and two operands as children and attach that node as the corresponding (left or right) child of the previous operator.
8. If the sign is + or -, then find create the node with the sign in it, one of the children being one of the operands and the second node being the root of the subtree with * and / at the root (or the second operand, if it’s a simple operation).

Getting pure arithmetic, with parentheses, working is easy; if-then is a bit more tricky, but still not too bad. About 10 years ago I had to implement something like this in Java. It took me about 3 days to get everything sorted and was in total about 500 lines of code in 1 class, not counting javadoc. I suspect in PHP it will be less code, due to sheer simplicity of PHP syntax and type conversions.

It may sound complicated, but, in reality, it’s much easier than it seems once you start doing it. I remember very well a university assignment to do something similar as part of the algorithms class, 17-18 years ago.