Ejemplo n.º 1
0
        public void LargerEqn3()
        {
            PostfixConverter converter = new PostfixConverter("12+3");
            List <string>    postfix   = converter.ConvertAndReturn();
            string           result    = "";

            foreach (string c in postfix)
            {
                result += c;
            }
            Assert.AreEqual(result, "123+");
        }
Ejemplo n.º 2
0
        public void ComplexEqn3()
        {
            PostfixConverter converter = new PostfixConverter("(3+4)*2*3+6");
            List <string>    postfix   = converter.ConvertAndReturn();
            string           result    = "";

            foreach (string c in postfix)
            {
                result += c;
            }
            Assert.AreEqual(result, "34+2*3*6+");
        }
Ejemplo n.º 3
0
        public void ComplexEqn1Inverse()
        {
            PostfixConverter converter = new PostfixConverter("2*3+1");
            List <string>    postfix   = converter.ConvertAndReturn();
            string           result    = "";

            foreach (string c in postfix)
            {
                result += c;
            }
            Assert.AreEqual(result, "23*1+");
        }
Ejemplo n.º 4
0
        public void SimpleEquation()
        {
            PostfixConverter converter = new PostfixConverter("1+2");
            List <string>    postfix   = converter.ConvertAndReturn();
            string           result    = "";

            foreach (string c in postfix)
            {
                result += c;
            }
            Assert.AreEqual(result, "12+");
        }
Ejemplo n.º 5
0
        public async Task MessageReceivedAsync(IDialogContext context, IAwaitable <Message> argument)
        {
            List <string>    equation;
            string           answer;
            var              message = await argument;
            PostfixConverter pf      = new PostfixConverter(message.Text);

            equation = pf.ConvertAndReturn();

            PfCalculator pfc = new PfCalculator();

            answer = pfc.CalculatePostfix(equation);
            await context.PostAsync($"The answer is: {answer}");

            context.Wait(MessageReceivedAsync);
        }
Ejemplo n.º 6
0
        /// <summary>
        /// event handler for autocorrecting the rule in the textbox
        /// </summary>
        private void ModificationTextBox_OnCtrlWPressed(object sender, KeyEventArgs keyEventArgs)
        {
            if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control && _cleanedRule != string.Empty) // Is Alt key pressed
            {
                if (Keyboard.IsKeyDown(Key.W))
                {
                    bool         bestVariableEver = false;
                    FlowDocument flow             = ModificationTextBox.Document;

                    while (!bestVariableEver)
                    {
                        var text = _cleanedRule;

                        text = PostfixConverter.Tokenize(text);
                        var ifMatches = Regex.Matches(text, @"(?<=(AKO))(.*)(?=(ONDA))|(?<=(ONDA))(.*)");

                        string test       = ifMatches[0].Value.Trim();
                        string testFactor = ifMatches[1].Value.Trim();
                        Console.WriteLine("First part of the expression: " + test);
                        Console.WriteLine("Second part of the expression: " + ifMatches[1].Value.Trim());



                        var tuple = ValidateExpression(test, testFactor);
                        flow             = tuple.Item1;
                        bestVariableEver = tuple.Item2;
                    }

                    _cleanedRule = _cleanedRule.Trim();

                    WarningLabel.Content = "Enjoy!!!!";

                    var paragraph = new Paragraph();
                    paragraph.Inlines.Add(_cleanedRule);
                    _cleanedRule = string.Empty;

                    ModificationTextBox.Document = flow;
                }
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Converts the expression and it's factor to their respective objects.
        /// If the conversion isn't successful, the invalid parts of the expression
        /// are colored red in the textbox as a warning to the user.
        /// </summary>
        /// <param name="expression">
        /// expression that needs to be validated
        /// </param>
        /// <param name="factor">
        /// factor part of the initial rule
        /// </param>
        /// <returns>
        /// flowDocument which contains the processed text,
        /// and a indicator whether the expression is valid
        /// </returns>
        private Tuple <FlowDocument, bool> ValidateExpression(string expression, string factor)
        {
            var expressionRegularized = true;

            _cleanedRule = string.Empty;

            // get all invalid character intervals in the expressions
            var errors = PostfixConverter.CheckInvalidCombinations(expression);

            int[] splitIndexes = new int[errors.Count * 2];

            // split the expression string on the good/bad intervals
            // bad will appear as even splits
            for (int i = 0; i < errors.Count; i++)
            {
                splitIndexes[2 * i]     = errors[i].Item1;
                splitIndexes[2 * i + 1] = errors[i].Item2 + 1;
            }

            Console.WriteLine("ALL ERRORS:");
            foreach (var error in errors)
            {
                Console.WriteLine(error + expression.Substring(error.Item1, error.Item2 - error.Item1 + 1));
            }

            var split = expression.SplitAt(splitIndexes);
            // wrapping each string to a decoreated Run object
            // and adding it to paragraph
            FlowDocument flow     = new FlowDocument();
            Paragraph    para     = new Paragraph();
            var          ifPart   = "AKO ";
            var          thenPart = " ONDA ";

            para.Inlines.Add(new Run(ifPart));
            _cleanedRule += ifPart;

            // wrap the intervals in a run object and
            // add it to the paragraph
            for (int i = 0; i < split.Length; i++)
            {
                if (i % 2 != 0)
                {
                    Brush brush = Brushes.Red;
                    var   run   = new Run(split[i])
                    {
                        Foreground = brush,
                        FontSize   = 20,
                        FontWeight = FontWeights.Bold
                    };
                    para.Inlines.Add(run);
                    expressionRegularized = false;
                }
                else
                {
                    para.Inlines.Add(new Run(split[i]));
                    _cleanedRule += " " + split[i] + " ";
                }
            }
            para.Inlines.Add(new Run(thenPart));
            para.Inlines.Add(new Run(factor));

            // clean necessary multiple spacings
            _cleanedRule += " " + thenPart + " ";
            _cleanedRule  = Regex.Replace(_cleanedRule, @"\s+", " ");
            _cleanedRule += factor;
            _cleanedRule  = Regex.Replace(_cleanedRule, @"\s+", " ");

            // add the paragraph
            flow.Blocks.Add(para);
            Console.WriteLine(
                new TextRange(RuleRichTextBox.Document.ContentStart, RuleRichTextBox.Document.ContentEnd).Text);

            return(new Tuple <FlowDocument, bool>(flow, expressionRegularized));
        }
Ejemplo n.º 8
0
        /// <summary>
        /// parses the entered rule. if the rule is valid
        /// adds it to rules, if not displays the invalid text
        /// in the rule textbox as red, which can be autocorrected
        /// with CTRL + W command
        /// </summary>
        private void RuleRichTextBox_EnterClicked(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Return)
            {
                string pattern = @"\(\d([,.]\d+)?\)";
                // this is how you get text from richtextbox
                string initialExpression =
                    new TextRange(RuleRichTextBox.Document.ContentStart, RuleRichTextBox.Document.ContentEnd).Text;
                string expression = initialExpression.Replace("\n", string.Empty).Replace("\r", string.Empty);

                expression = Regex.Replace(expression, @"\s+", " ");

                // tokenize the expression
                expression = PostfixConverter.Tokenize(expression);


                // checking if the sentence begins with an IF
                var ifBeginMatch = Regex.Matches(expression, @"^(:?AKO\s)");

                if (ifBeginMatch.Count == 0)
                {
                    WarningLabel.Content = "Expression not beginning with IF, please reenter";
                    return;
                }

                //Grabbing expression & conclusion
                var ifMatches = Regex.Matches(expression, @"(?<=(AKO))(.*)(?=(ONDA))|(?<=(ONDA))(.*)");

                if (ifMatches.Count == 0)
                {
                    WarningLabel.Content = "Unallowed input, rewrite the rule";
                    return;
                }

                // trim the factor/expression part
                string test       = ifMatches[0].Value.Trim();
                string testFactor = ifMatches[1].Value.Trim();

                Console.WriteLine("First part of the expression: " + test);
                Console.WriteLine("Second part of the expression: " + ifMatches[1].Value.Trim());

                // Checks whether the conclusion is valid
                if (!Regex.IsMatch(ifMatches[1].Value, @"\s*\(\s*\d([,.]\d+)?\s*\)\s*"))
                {
                    WarningLabel.Content = "Conclusion parsing failed, check after THEN";
                    return;
                }

                // Validate the expression
                var tuple = ValidateExpression(test, testFactor);

                // set the TextBox Document and regularized flag
                RuleRichTextBox.Document = tuple.Item1;
                var expressionRegularized = tuple.Item2;

                if (expressionRegularized)
                {
                    // prepare the expression for the caching part
                    var replacedExpression = expression
                                             .Replace(Regex.Match(expression, pattern).ToString(), string.Empty)
                                             .Replace("( ", "(")
                                             .Replace(" )", ")")
                                             .Replace("  ", " ");

                    Rule modRule = MainWindow.GetCachedRule(replacedExpression);

                    if (modRule == null)
                    {
                        try
                        {
                            AddRule(PostfixConverter.RuleConversion(expression));
                        }
                        catch (ParsingException ex)
                        {
                            WarningLabel.Content     = ex.Message;
                            RuleRichTextBox.Document = new FlowDocument();
                        }
                    }
                    else
                    {
                        // regex for extracting the factor
                        string match  = Regex.Match(expression, @"[0-9]([.,][0-9]{1,3})?").ToString();
                        double factor = double.Parse(match);
                        modRule.ObservedConclusionFactor = factor;
                    }

                    _factor = string.Empty;

                    RuleRichTextBox.Document = new FlowDocument();
                }
                else
                {
                    WarningLabel.Content = "Potential sytax mistakes. Press Ctrl+W for autocorrect";
                }



                e.Handled = true;
            }
            else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control && _cleanedRule != string.Empty)
            {
                if (Keyboard.IsKeyDown(Key.W))
                {
                    bool         bestVariableEver = false;
                    FlowDocument flow             = RuleRichTextBox.Document;

                    // loop until all the mistakes are corrected
                    while (!bestVariableEver)
                    {
                        var text = _cleanedRule;

                        text = PostfixConverter.Tokenize(text);
                        var ifMatches = Regex.Matches(text, @"(?<=(AKO))(.*)(?=(ONDA))|(?<=(ONDA))(.*)");

                        string test       = ifMatches[0].Value.Trim();
                        string testFactor = ifMatches[1].Value.Trim();
                        Console.WriteLine("First part of the expression: " + test);
                        Console.WriteLine("Second part of the expression: " + ifMatches[1].Value.Trim());



                        var tuple = ValidateExpression(test, testFactor);
                        flow             = tuple.Item1;
                        bestVariableEver = tuple.Item2;
                    }

                    _cleanedRule = _cleanedRule.Trim();


                    WarningLabel.Content = "Enjoy!!!!";

                    var paragraph = new Paragraph();
                    paragraph.Inlines.Add(_cleanedRule);
                    _cleanedRule = string.Empty;


                    RuleRichTextBox.Document = flow;
                }
            }
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Converts the text from the textbox to a rule.
        /// If the conversion isn't possible, display
        /// invalid values colored red in the textbox as a warning,
        /// with an option of autocorrection on CTRL + W.
        /// If created rule is present in the system, do nothing.
        /// Else update the rules collection with the newly created rule.
        /// </summary>
        private void OkButton_Click(object sender, RoutedEventArgs e)
        {
            MainWindow mainWindow = this.Owner as MainWindow;
            string     pattern    = @"\(\s*\d([,.]\d+)?\s*\)";
            var        unmod      = UnModifiedRule.Replace(Regex.Match(UnModifiedRule, pattern).ToString(), string.Empty);


            Rule unModRule = MainWindow.GetCachedRule(unmod);

            // this is how you get text from richtextbox
            string expression = new TextRange(ModificationTextBox.Document.ContentStart, ModificationTextBox.Document.ContentEnd).Text;

            expression = expression.Replace("\n", string.Empty).Replace("\r", string.Empty);

            expression = Regex.Replace(expression, @"\s+", " ");

            expression = PostfixConverter.Tokenize(expression);

            // checking if the sentence begins with an IF
            var ifBeginMatch = Regex.Matches(expression, @"^(:?AKO\s)");

            if (ifBeginMatch.Count == 0)
            {
                WarningLabel.Content = "Expression not beginning with IF, please reenter";
                return;
            }

            //Grabbing expression & conclusion
            var ifMatches = Regex.Matches(expression, @"(?<=(AKO))(.*)(?=(ONDA))|(?<=(ONDA))(.*)");

            if (ifMatches.Count == 0)
            {
                WarningLabel.Content = "Unallowed input, rewrite the rule";
                return;
            }

            // trim the match values
            string test       = ifMatches[0].Value.Trim();
            string testFactor = ifMatches[1].Value.Trim();

            Console.WriteLine("First part of the expression: " + test);
            Console.WriteLine("Second part of the expression: " + ifMatches[1].Value.Trim());

            if (!Regex.IsMatch(ifMatches[1].Value, @"\s*\(\s*\d([,.]\d+)?\s*\)\s*((\d|\w)+)$"))
            {
                WarningLabel.Content = "Conclusion parsing failed, check after THEN";
                return;
            }

            // validate the expression
            var tuple = ValidateExpression(test, testFactor);

            ModificationTextBox.Document = tuple.Item1;
            var expressionRegularized = tuple.Item2;

            if (expressionRegularized)
            {
                // clean the expression
                var replacedExpression = expression
                                         .Replace(Regex.Match(expression, pattern).ToString(), string.Empty)
                                         .Replace("( ", "(")
                                         .Replace(" )", ")")
                                         .Replace("  ", " ");


                Rule modRule = MainWindow.GetCachedRule(replacedExpression);

                if (modRule == null)
                {
                    MainWindow.ReplaceRule(unModRule, PostfixConverter.RuleConversion(expression));
                }
                else
                {
                    // regex for extracting the factor
                    string match     = Regex.Match(testFactor, @"[0-9]([.,][0-9]{1,3})?").ToString();
                    double factor    = double.Parse(match);
                    double TOLERANCE = 0.0001;

                    if (Math.Abs(factor - unModRule.ObservedConclusionFactor) > TOLERANCE)
                    {
                        unModRule.ObservedConclusionFactor = factor;
                    }
                }

                _factor = string.Empty;

                Close();
            }
            else
            {
                WarningLabel.Content = "Potential sytax mistakes. Press Ctrl+W for autocorrect";
            }
        }