Comparing operators for precedence

[eeasss]

Hi all, i am writing an impementation of the shunting yard algorithm for practicing basic data structures but i have encountered the following problem: I need to compare two operators in terms of precedence. Is this possible in C#?
Example * > + should return true.

[Plater]

I am not sure there is any method that will tell you what operator has presidence, unless you can write your own test cases? I believe they are implemented following mathmatical standards and are thus effected by use of ( ) as well.

Such as

int x = 10 * 5 + 1;
//this will either be 60 or 51 depending on operator precendence right?
 

[TRScheel]

Based off my readings of the shunting yard algorithm (which is pretty cool imho) this should get you on the right road to doing what you want:

enum Operators
{
    None = 0,
    AdditionSubtraction = 1,
    MultiplicationDivision = 5,
    ExponentRoot = 10
}
 
static Operators GetOperatorWeight(char value)
{
    if (value == '^')
        return Operators.ExponentRoot;
    else if (value == '*' || value == '/')
        return Operators.MultiplicationDivision;
    else if (value == '+' || value == '-')
        return Operators.AdditionSubtraction;
    else
        return Operators.None;
}
 

Note that you would pass the equation one char at a time. You will have to fill in the logic/expand for other symbols and numbers.

[Plater]

So I looked up shunting yard and well, couldn't figure out what it was useful for?
Maybe I didn't read it enough?

Input : 3 + 4 * 2 / ( 1 − 5 ) ^ 2 ^ 3
Output: 3 4 2 * 1 5 - 2 3 ^ ^ / +

What does that tell us?
Work left-right on numbers and right-left on operators?

[eeasss]

Thanks everyone for the replays. I solved the problem myself using dictionary

   private static Dictionary<string, int> OperatorPrecedence()
        {
            Dictionary<string, int> operators = new Dictionary<string, int>();
            operators.Add("+", 1);
            operators.Add("-", 1);
            operators.Add("*", 2);
            operators.Add("/", 2);
            return operators;
        }
 
 
and then compare the oprators like:
 
   if (precedence[temp[i]] <= precedence[operStack.Peek()])
                        {
                            output.Enqueue(operStack.Pop());
                        }

... etc

where temp[i] is the array of my tokens. By the way the enumeration thing looks also pretty good, i might try it.

@ plater - shunting yard is used when u want to convert expressions from infix to postfix notation. This is usefull for calculators for example, because it eliminates the need for parenthesis and thus the calculations are easier :)