private double evaluationOfRPN(Configuration config)
        {
            int counter = 0;

            Stack <double> stack = new Stack <double>();

            if (expressionArray.Length == 0)
            {
                return(1);
            }

            while (counter < expressionArray.Length)
            {
                string curr = expressionArray[counter];
                counter++;

                if (!InfluenceFunction.isOperatorEval(curr))
                {
                    stack.Push(getValueOfToken(config, curr, varModel));
                }
                else
                {
                    if (curr.Equals("+"))
                    {
                        double rightHandSide = stack.Pop();
                        if (stack.Count == 0)
                        {
                            stack.Push(rightHandSide);
                        }
                        double leftHandSide = stack.Pop();
                        stack.Push(leftHandSide + rightHandSide);
                    }
                    if (curr.Equals("*"))
                    {
                        double rightHandSide = stack.Pop();
                        double leftHandSide  = stack.Pop();
                        stack.Push(leftHandSide * rightHandSide);
                    }
                    // TODO log(0) == ????
                    if (curr.Equals("]"))
                    {
                        double leftHandSide = stack.Pop();
                        if (leftHandSide == 0.0)
                        {
                            stack.Push(0.0);
                        }
                        else
                        {
                            stack.Push(Math.Log(leftHandSide, 10.0));
                        }
                    }
                }
            }

            return(stack.Pop());
        }
        private double evaluationOfRPN(Dictionary <NumericOption, double> config)
        {
            int counter = 0;

            if (expressionArray.Length == 0)
            {
                return(0);
            }

            Stack <double> stack = new Stack <double>();

            while (counter < expressionArray.Length)
            {
                string curr = expressionArray[counter];
                counter++;

                if (!InfluenceFunction.isOperatorEval(curr))
                {
                    stack.Push(getValueOfToken(config, curr, varModel));
                }
                else
                {
                    if (curr.Equals("+"))
                    {
                        if (stack.Count < 2)
                        {
                            Console.WriteLine("Error. Possible reason: name of numeric option does not match the name in the stepsize XML-tag");
                        }

                        double rightHandSide = stack.Pop();
                        double leftHandSide  = stack.Pop();
                        stack.Push(leftHandSide + rightHandSide);
                    }
                    if (curr.Equals("*"))
                    {
                        double rightHandSide = stack.Pop();
                        double leftHandSide  = stack.Pop();
                        stack.Push(leftHandSide * rightHandSide);
                    }
                    if (curr.Equals("]"))
                    {
                        double leftHandSide = stack.Pop();
                        if (leftHandSide == 0.0)
                        {
                            stack.Push(Double.MinValue);
                        }
                        else
                        {
                            stack.Push(Math.Log(leftHandSide, 10.0));
                        }
                    }
                }
            }

            return(stack.Pop());
        }
        private double evaluationOfRPN(Configuration config)
        {
            int counter = 0;

            Stack <double> stack = new Stack <double>();

            if (expressionArray.Length == 0)
            {
                return(1);
            }

            while (counter < expressionArray.Length)
            {
                string curr = expressionArray[counter];
                counter++;

                if (!InfluenceFunction.isOperatorEval(curr))
                {
                    stack.Push(getValueOfToken(config, curr, varModel));
                }
                else
                {
                    if (curr.Equals("+"))
                    {
                        double rightHandSide = stack.Pop();
                        if (stack.Count == 0)
                        {
                            stack.Push(rightHandSide);
                        }
                        double leftHandSide = stack.Pop();
                        if (counter < expressionArray.Length && expressionArray[counter].Equals("-"))
                        {
                            stack.Push(leftHandSide - rightHandSide);
                        }
                        else
                        {
                            stack.Push(leftHandSide + rightHandSide);
                        }
                    }
                    if (curr.Equals("-"))
                    {
                        double rightHandSide = stack.Pop();
                        if (stack.Count == 0)
                        {
                            stack.Push(rightHandSide);
                        }
                        double leftHandSide = stack.Pop();
                        if (counter < expressionArray.Length && expressionArray[counter].Equals("-"))
                        {
                            stack.Push(leftHandSide + rightHandSide);
                        }
                        else
                        {
                            stack.Push(leftHandSide - rightHandSide);
                        }
                    }
                    if (curr.Equals("*"))
                    {
                        double rightHandSide = stack.Pop();
                        double leftHandSide  = stack.Pop();
                        stack.Push(leftHandSide * rightHandSide);
                    }
                    if (curr.Equals("/"))
                    {
                        double rightHandSide = stack.Pop();
                        double leftHandSide  = stack.Pop();
                        if (leftHandSide == 0.0 || rightHandSide == 0.0)
                        {
                            stack.Push(0.0);
                        }
                        else
                        {
                            stack.Push(leftHandSide / rightHandSide);
                        }
                    }
                    if (curr.Equals("]"))
                    {
                        double leftHandSide = stack.Pop();
                        if (leftHandSide == 0.0)
                        {
                            GlobalState.logError.log("part of the performance-influence model leads to a NegativeInfinity (compute log(0)) ");
                            stack.Push(0.0);
                        }
                        else
                        {
                            stack.Push(Math.Log(leftHandSide, 10.0));
                        }
                    }
                }
            }

            return(stack.Pop());
        }