How to parse a string starting by the end c++

Question

Added another example.

I have a mathematical expression such as cos(pi*cos(pi * sin(pi*y))) and I want to solve it.

I think the best way to parse it is starting by the end of the string.

So, in the expression above:

1. i = sin(pi*y)
2. i = cos(pi*i)
3. i = cos(pi*i)

I'm going to add another expression as example: cos(pi*(avg(x,x)*y))

This should be evaluated like this:

1. i = avg(x,x)
2. i = i*y
3. i = cos(pi*i)

What do you think about it? Could you help me to implement a the code?

Thanks in advance

Answer 1

I have a mathematical expression such as cos(pi*cos(pi * sin(pi*y))) and I want to solve it.

No, you want to evaluate it. Solving tells you the conditions under which something is true. Evaluating it just gives you a resulting value.

I think the best way to parse it is starting by the end of the string.

The traditional way of parsing expressions like this is using recursive descent. It's more general and much easier to implement. The control flow looks something like this:

• cos ( A ...

  • where A = pi * cos ( B ...

    • where B = pi * sin ( C ...

      • where C = pi * y

        now you can evaluate pi * y, and return the value of C

      ... and now you have C, you can evaluate pi * sin(C) and return the value of B

    ... and now you have the value of B, you can evaluate pi * cos(B), returning the value as A

  ... and now you have the value of A, you can evaluate cos(A), and you're done.

This is exactly the way the C expression cos(M_PI * cos(M_PI * sin(M_PI * y))) works (assuming the common but non-standard constant for π).

It is evaluated roughly right-to-left (actually inner-to-outer), but still read left-to-right. We've just labelled the temporary values for clarity.

This control flow is often simply turned into a tree like

[cos of _]
        |
    [pi * _]
          |
     [cos of _]
             |
         [pi * _]
               |
          [sin of _]
                  |
              [pi * y]

But obviously you can just evaluate the result once unless you need to save the tree for later. (Note this lopsided tree is still a tree, it's just degenerate because of the way your expression is nested).

...What do you think about it?

The problem with your solution is that it breaks for different nesting structures, eg.

cos( sin((pi * x) + y) + sin(y + (pi * x)) )

can't simply be evaluated right-to-left.

Could you help me to implement the code?

Separate the string processing (tokenization) from the parsing and evaluation. It's much easier to reason independently about your string processing and your maths.

Answer 2

EDITED: Base case improvement.

This is just some pseudo code, but the idea should work:

int ParseAndCalculate(string input)
{
    if (input.DoesConvertToSomeIntegerWork())
        return input.ConvertToSomeInteger();

    string actionRequired = GetActionFromString(input, "(");
    int tempIndex = input.LocationOfFirst("(");
    int tempResult = ParseAndCalculate(input, tempIndex, input.Length -1);
    tempResult = PerformRequiredAction(tempResult, actionRequired);

    return tempResult;
}

Not sure what you should return at the base case. Maybe work out what the actual value is in there?

Answer 3

If you want to write a C/C++ program that can parse mathematical expressions like the above, you can write a top-down parser in C/C++ yourself, or you might want to have a look at GNU Bison.

Bison is a parser generator, and it happens to come with an example that's quite close to your problem.

The benefits of using it would be that you don't need to care about the actual parsing routines yourself, but can focus on the grammar specification and the mathematical function callbacks. I have to admit that getting into Bison and integrating it into the build may be quite an effort. I can't tell if it's really useful in your situation, but at least it's an established and robust tool used when solving such tasks.

It can also be used for evaluating expressions in the "correct" order, because it supports operator precedence definitions.