コード例 #1
0
        public void Parse(RawExpression rawExpression)
        {
            RawExpressionParser         parser         = new RawExpressionParser(rawExpression);
            IEnumerable <RawMultiplier> rawMultipliers = parser.Iterator();

            foreach (RawMultiplier rawMultiplier in rawMultipliers)
            {
                Multiplier multiplier = new Multiplier(rawMultiplier);
                Expression expression = multiplier.ConvertToExpression();
                this.Join(expression);
            }
        }
コード例 #2
0
ファイル: Normalizer.cs プロジェクト: nskrypnik/News360Test
        /**
         *  Main magic is happening here
         */
        public string Normalize(string equation)
        {
            string[]   parts = equation.Split(new char[] { '=' });
            Expression parsedEquation;
            Multiplier rightPart;

            if (parts.Length != 2)
            {
                return("Equation is incorrect, it should have two parts and equal sign");
            }
            string leftPartRaw  = parts[0];             // get left part
            string rightPartRaw = "(" + parts[1] + ")"; // and right part
            int    rightOffset  = equation.IndexOf('=') + 1;

            try
            {
                // parse left part as an Expression
                parsedEquation = new Expression(new RawExpression(0, leftPartRaw));
            }
            catch (ParseException e)
            {
                // parse right part as Multiplier as we want eventually multiply it to -1
                return(this.HandleException(equation, e));
            }

            try
            {
                rightPart = new Multiplier(new RawMultiplier(rightOffset, rightPartRaw, -1));
            }
            catch (ParseException e)
            {
                return(this.HandleException(equation, e));
            }

            // If I wrote it in Python I would very likely use PyParser package which make life
            // a way easier for parsing expressions like this, but I decided to go hardcore
            // and write it on C# for which breaf search didn't get result of analogues of
            // PyParse in .NET world. So I simply wrote my own parsers

            // then join left part expression and converted multiplier to expression
            parsedEquation.Join(rightPart.ConvertToExpression());

            // do sorting
            List <Summand> sortedSummands = this.Sort(parsedEquation.summands);

            return(this.GenerateEquationString(sortedSummands));
        }